blacklight 7.0.0.rc1 → 7.0.0.rc2

data/spec/helpers/blacklight/hash_as_hidden_fields_behavior_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Blacklight::HashAsHiddenFieldsHelperBehavior do
       per_page: 10,
       page: 5,
       extra_arbitrary_key: "arbitrary_value",
-      f: { field1: %w(a b), field2: ["z"] } }
+      f: { field1: %w[a b], field2: ["z"] } }
   end
   let(:generated) { helper.render_hash_as_hidden_fields(params) }
 

data/spec/helpers/blacklight/icon_helper_behavior_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 RSpec.describe Blacklight::IconHelperBehavior do
   describe '#blacklight_icon' do
     it 'wraps the svg in a span with classes' do

data/spec/helpers/blacklight/render_constraints_helper_behavior_spec.rb

@@ -16,9 +16,10 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
   end
 
   describe '#render_constraints_query' do
+    subject { helper.render_constraints_query(params) }
+
     let(:my_engine) { double("Engine") }
     let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }) }
-    subject { helper.render_constraints_query(params) }
 
     it "has a link relative to the current url" do
       expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
@@ -34,6 +35,7 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
 
     context "with a route_set" do
       let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }, route_set: my_engine) }
+
       it "accepts an optional route set" do
         expect(my_engine).to receive(:url_for).and_return('/?f%5Btype%5D=journal')
         expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
@@ -42,11 +44,12 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
   end
 
   describe '#render_filter_element' do
+    subject { helper.render_filter_element('type', ['journal'], path) }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(config)
       expect(helper).to receive(:facet_field_label).with('type').and_return("Item Type")
     end
-    subject { helper.render_filter_element('type', ['journal'], path) }
 
     let(:params) { ActionController::Parameters.new q: 'biz' }
     let(:path) { Blacklight::SearchState.new(params, config, controller) }
@@ -66,12 +69,14 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
   end
 
   describe "#render_constraints_filters" do
+    subject { helper.render_constraints_filters(params) }
+
     let(:params) { ActionController::Parameters.new f: { 'type' => [''] } }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(config)
       allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
     end
-    subject { helper.render_constraints_filters(params) }
 
     it "renders nothing for empty facet limit param" do
       expect(subject).to be_blank

data/spec/helpers/blacklight/render_partials_helper_behavior_spec.rb

@@ -1,31 +1,39 @@
+# frozen_string_literal: true
+
 RSpec.describe Blacklight::RenderPartialsHelperBehavior do
   describe "#type_field_to_partial_name" do
-    let(:document) { double }
     subject { helper.send(:type_field_to_partial_name, document, value) }
 
+    let(:document) { double }
+
     context "with default value" do
       let(:value) { 'default' }
+
       it { is_expected.to eq 'default' }
     end
 
     context "with spaces" do
       let(:value) { 'one two three' }
+
       it { is_expected.to eq 'one_two_three' }
     end
 
     context "with hyphens" do
       let(:value) { 'one-two-three' }
+
       it { is_expected.to eq 'one_two_three' }
     end
 
     context "an array" do
-      let(:value) { ['one', 'two', 'three'] }
+      let(:value) { %w[one two three] }
+
       it { is_expected.to eq 'one_two_three' }
     end
   end
 
   describe "#render_document_partials" do
     let(:doc) { double }
+
     before do
       allow(helper).to receive_messages(document_partial_path_templates: [])
       allow(helper).to receive_messages(document_index_view_type: 'index_header')
@@ -39,19 +47,22 @@ RSpec.describe Blacklight::RenderPartialsHelperBehavior do
 
   describe "#document_partial_name" do
     let(:blacklight_config) { Blacklight::Configuration.new }
+
     before do
       allow(helper).to receive_messages(blacklight_config: blacklight_config)
     end
 
     context "with a solr document with empty fields" do
       let(:document) { SolrDocument.new }
+
       it "is the default value" do
         expect(helper.document_partial_name(document)).to eq 'default'
       end
     end
 
     context "with a solr document with the display type field set" do
-      let(:document) { SolrDocument.new 'my_field' => 'xyz'}
+      let(:document) { SolrDocument.new 'my_field' => 'xyz' }
+
       before do
         blacklight_config.show.display_type_field = 'my_field'
       end
@@ -66,15 +77,16 @@ RSpec.describe Blacklight::RenderPartialsHelperBehavior do
 
     context "with a solr doucment with an action-specific field set" do
       let(:document) { SolrDocument.new 'my_field' => 'xyz', 'other_field' => 'abc' }
+
       before do
         blacklight_config.show.media_display_type_field = 'my_field'
         blacklight_config.show.metadata_display_type_field = 'other_field'
       end
+
       it "uses the value in the action-specific fields" do
         expect(helper.document_partial_name(document, :media)).to eq 'xyz'
         expect(helper.document_partial_name(document, :metadata)).to eq 'abc'
       end
     end
   end
-
 end

data/spec/helpers/blacklight/search_history_constraints_helper_behavior_spec.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
-
   before(:all) do
     @config = Blacklight::Configuration.new do |config|
-      config.add_search_field 'default_search_field', :label => 'Default'
+      config.add_search_field 'default_search_field', label: 'Default'
 
-      config.add_facet_field 'some_facet', :label => 'Some'
-      config.add_facet_field 'other_facet', :label => 'Other'
+      config.add_facet_field 'some_facet', label: 'Some'
+      config.add_facet_field 'other_facet', label: 'Other'
       config.add_facet_field 'i18n_facet'
 
-      I18n.backend.store_translations(:en, blacklight: {search: {fields: {facet: {i18n_facet: 'English facet label'}}}})
-      I18n.backend.store_translations(:de, blacklight: {search: {fields: {facet: {i18n_facet: 'German facet label'}}}})
+      I18n.backend.store_translations(:en, blacklight: { search: { fields: { facet: { i18n_facet: 'English facet label' } } } })
+      I18n.backend.store_translations(:de, blacklight: { search: { fields: { facet: { i18n_facet: 'German facet label' } } } })
     end
   end
 
-  before(:each) do
+  before do
     allow(helper).to receive(:blacklight_config).and_return(@config)
   end
 
@@ -23,7 +22,7 @@ RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
     describe "render_search_to_s_element" do
       it "renders basic element" do
         response = helper.render_search_to_s_element("key", "value")
-        expect(response).to have_selector("span.constraint")  do |span|
+        expect(response).to have_selector("span.constraint") do |span|
           expect(span).to have_selector("span.filter-name", content: "key:")
           expect(span).to have_selector("span.filter-value", content: "value")
         end
@@ -31,21 +30,21 @@ RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
       end
       it "escapes them that need escaping" do
         response = helper.render_search_to_s_element("key>", "value>")
-        expect(response).to have_selector("span.constraint") do |span|          
+        expect(response).to have_selector("span.constraint") do |span|
           expect(span).to have_selector("span.filter-name") do |s2|
             # Note: nokogiri's gettext will unescape the inner html
-            # which seems to be what rspecs "contains" method calls on 
+            # which seems to be what rspecs "contains" method calls on
             # text nodes - thus the to_s inserted below.
             expect(s2).to match(/key>:/)
           end
-          expect(span).to have_selector("span.filter-value") do |s3|            
+          expect(span).to have_selector("span.filter-value") do |s3|
             expect(s3).to match(/value>/)
           end
         end
         expect(response).to be_html_safe
       end
       it "does not escape with options set thus" do
-        response = helper.render_search_to_s_element("key>", "value>", :escape_key => false, :escape_value => false)
+        response = helper.render_search_to_s_element("key>", "value>", escape_key: false, escape_value: false)
         expect(response).to have_selector("span.constraint") do |span|
           expect(span).to have_selector("span.filter-name", content: "key>:")
           expect(span).to have_selector("span.filter-value", content: "value>")
@@ -56,29 +55,30 @@ RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
 
     describe "render_search_to_s" do
       before do
-        @params = {:q => "history", :f => {"some_facet" => ["value1", "value1"],  "other_facet" => ["other1"]}}        
+        @params = { q: "history", f: { "some_facet" => %w[value1 value1], "other_facet" => ["other1"] } }
       end
+
       it "calls lesser methods" do
         allow(helper).to receive(:blacklight_config).and_return(@config)
-        allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(:key => 'default_search_field', :display_label => 'Default'))
+        allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(key: 'default_search_field', display_label: 'Default'))
         allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
         # API hooks expect this to be so
         response = helper.render_search_to_s(@params)
 
-        expect(response).to include( helper.render_search_to_s_q(@params))
-        expect(response).to include( helper.render_search_to_s_filters(@params))
+        expect(response).to include(helper.render_search_to_s_q(@params))
+        expect(response).to include(helper.render_search_to_s_filters(@params))
         expect(response).to be_html_safe
       end
     end
-    
+
     describe "render_search_to_s_filters" do
       it "renders a constraint for a selected facet in the config" do
-        response = helper.render_search_to_s_filters(:f => {"some_facet" => ["value1", "value2"]})
+        response = helper.render_search_to_s_filters(f: { "some_facet" => %w[value1 value2] })
         expect(response).to eq("<span class=\"constraint\"><span class=\"filter-name\">Some:</span><span class=\"filter-values\"><span class=\"filter-value\">value1</span><span class=\"filter-separator\"> and </span><span class=\"filter-value\">value2</span></span></span>")
       end
 
       it "renders a constraint for a selected facet not in the config" do
-        response = helper.render_search_to_s_filters(:f => {"undefined_facet" => ["value1", "value2"]})
+        response = helper.render_search_to_s_filters(f: { "undefined_facet" => %w[value1 value2] })
         expect(response).to eq("<span class=\"constraint\"><span class=\"filter-name\">#{'undefined_facet'.titleize}:</span><span class=\"filter-values\"><span class=\"filter-value\">value1</span><span class=\"filter-separator\"> and </span><span class=\"filter-value\">value2</span></span></span>")
       end
 
@@ -92,14 +92,13 @@ RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
         end
 
         it 'renders the correct I18n label for a selected facet with I18n translations' do
-          {en: 'English facet label', de: 'German facet label'}.each do |locale, label|
+          { en: 'English facet label', de: 'German facet label' }.each do |locale, label|
             I18n.locale = locale
-            response = helper.render_search_to_s_filters(f: {'i18n_facet' => ['value1', 'value2']})
+            response = helper.render_search_to_s_filters(f: { 'i18n_facet' => %w[value1 value2] })
             expect(response).to include(label)
           end
         end
       end
     end
   end
-
 end

data/spec/helpers/blacklight/suggest_helper_behavior_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Blacklight::SuggestHelperBehavior do
     allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
     expect(Deprecation).to receive(:warn)
   end
-  
+
   describe '#autocomplete_enabled?' do
     describe 'with autocomplete config' do
       let(:blacklight_config) do
@@ -14,10 +14,12 @@ RSpec.describe Blacklight::SuggestHelperBehavior do
           config.autocomplete_path = 'suggest'
         end
       end
+
       it 'is enabled' do
         expect(helper.autocomplete_enabled?).to be true
       end
     end
+
     describe 'without disabled config' do
       let(:blacklight_config) do
         Blacklight::Configuration.new.configure do |config|
@@ -25,16 +27,19 @@ RSpec.describe Blacklight::SuggestHelperBehavior do
           config.autocomplete_path = 'suggest'
         end
       end
+
       it 'is disabled' do
         expect(helper.autocomplete_enabled?).to be false
       end
     end
+
     describe 'without path config' do
       let(:blacklight_config) do
         Blacklight::Configuration.new.configure do |config|
           config.autocomplete_enabled = true
         end
       end
+
       it 'is disabled' do
         expect(helper.autocomplete_enabled?).to be false
       end

data/spec/helpers/blacklight/url_helper_behavior_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::UrlHelperBehavior do
-
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
       config.index.title_field = 'title_tsim'
@@ -37,7 +36,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
     it "allows for custom show routes" do
       helper.blacklight_config.show.route = { controller: 'catalog' }
-      expect(helper.url_for_document(doc)).to eq({controller: 'catalog', action: :show, id: doc})
+      expect(helper.url_for_document(doc)).to eq(controller: 'catalog', action: :show, id: doc)
     end
 
     context "within bookmarks" do
@@ -53,7 +52,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
       before do
         helper.blacklight_config.show.route = { controller: :current }
-        allow(helper).to receive(:params).and_return(parameter_class.new controller: 'alternate')
+        allow(helper).to receive(:params).and_return(parameter_class.new(controller: 'alternate'))
       end
 
       it "supports the :current controller configuration" do
@@ -70,27 +69,26 @@ RSpec.describe Blacklight::UrlHelperBehavior do
   end
 
   describe "link_back_to_catalog" do
-    let(:query_params)  {{:q => "query", :f => "facets", :controller=>'catalog'}}
-    let(:bookmarks_query_params) {{ :controller=>'bookmarks'}}
+    let(:query_params) { { q: "query", f: "facets", controller: 'catalog' } }
+    let(:bookmarks_query_params) { { controller: 'bookmarks' } }
 
     it "builds a link tag to catalog using session[:search] for query params" do
-      allow(helper).to receive(:current_search_session).and_return double(:query_params => query_params)
+      allow(helper).to receive(:current_search_session).and_return double(query_params: query_params)
       tag = helper.link_back_to_catalog
       expect(tag).to match /q=query/
       expect(tag).to match /f=facets/
-      expect(tag).to_not match /page=/
-      expect(tag).to_not match /per_page=/
+      expect(tag).not_to match /page=/
+      expect(tag).not_to match /per_page=/
     end
 
     it "builds a link tag to bookmarks using session[:search] for query params" do
-      allow(helper).to receive(:current_search_session).and_return double(:query_params => bookmarks_query_params)
+      allow(helper).to receive(:current_search_session).and_return double(query_params: bookmarks_query_params)
       tag = helper.link_back_to_catalog
       expect(tag).to match /Back to Bookmarks/
-      expect(tag).to match /\/bookmarks/
+      expect(tag).to match %r{/bookmarks}
     end
 
     context "with a search context" do
-
       it "uses the current search session counter and per page information to construct the appropriate pagination context" do
         allow(helper).to receive_messages(current_search_session: double(query_params: query_params))
         allow(helper).to receive_messages(search_session: { 'per_page' => 15, 'counter' => 31 })
@@ -104,34 +102,35 @@ RSpec.describe Blacklight::UrlHelperBehavior do
         allow(helper).to receive_messages(search_session: { 'per_page' => 10, 'counter' => 31 })
         tag = helper.link_back_to_catalog
         expect(tag).to match /page=4/
-        expect(tag).to_not match /per_page=/
+        expect(tag).not_to match /per_page=/
       end
     end
 
     context "without current search context" do
+      subject { helper.link_back_to_catalog }
+
       before do
         controller.request.assign_parameters(Rails.application.routes, 'catalog', 'show', { id: '123' }, '/catalog/123', [:controller, :action, :id])
         allow(helper).to receive_messages(current_search_session: nil)
       end
 
-      subject { helper.link_back_to_catalog }
-
       it "links to the catalog" do
         expect(subject).to eq '<a href="/catalog">Back to Search</a>'
       end
     end
 
     context "when an alternate scope is passed in" do
-      let(:my_engine) { double("Engine") }
       subject(:tag) { helper.link_back_to_catalog(route_set: my_engine) }
 
+      let(:my_engine) { double("Engine") }
+
       before do
-        allow(helper).to receive(:current_search_session).and_return double(:query_params => query_params)
+        allow(helper).to receive(:current_search_session).and_return double(query_params: query_params)
       end
 
       it "calls url_for on the engine scope" do
         expect(my_engine).to receive(:url_for)
-          .with(q:"query", f: "facets", controller: "catalog")
+          .with(q: "query", f: "facets", controller: "catalog")
           .and_return('link-url')
         expect(tag).to match /Back to Search/
         expect(tag).to match /link-url/
@@ -142,6 +141,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
   describe "link_to_previous_document" do
     context "when the argument is nil" do
       subject { helper.link_to_previous_document(nil) }
+
       it { is_expected.to eq '<span class="previous">&laquo; Previous</span>' }
     end
   end
@@ -152,7 +152,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
       allow(helper).to receive_messages(params: parameter_class.new)
       tag = helper.link_to_query(query)
       expect(tag).to match /q=#{query}/
-      expect(tag).to match />#{query}<\/a>/
+      expect(tag).to match %r{>#{query}</a>}
     end
 
     it "builds a link tag to catalog using query string and other existing params" do
@@ -168,7 +168,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
       allow(helper).to receive_messages(params: parameter_class.new(page: "2", qt: "author_search"))
       tag = helper.link_to_query(query)
       expect(tag).to match /qt=author_search/
-      expect(tag).to_not match /page/
+      expect(tag).not_to match /page/
     end
 
     it "is html_safe" do
@@ -181,15 +181,15 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
   describe "start_over_path" do
     it 'is the catalog path with the current view type' do
-      allow(blacklight_config).to receive(:view) { { list: nil, abc: nil} }
-      allow(helper).to receive_messages(:blacklight_config => blacklight_config)
-      expect(helper.start_over_path(:view => 'abc')).to eq search_catalog_url(:view => 'abc')
+      allow(blacklight_config).to receive(:view).and_return(list: nil, abc: nil)
+      allow(helper).to receive_messages(blacklight_config: blacklight_config)
+      expect(helper.start_over_path(view: 'abc')).to eq search_catalog_url(view: 'abc')
     end
 
     it 'does not include the current view type if it is the default' do
-      allow(blacklight_config).to receive(:view) { { list: nil, asdf: nil} }
-      allow(helper).to receive_messages(:blacklight_config => blacklight_config)
-      expect(helper.start_over_path(:view => 'list')).to eq search_catalog_url
+      allow(blacklight_config).to receive(:view).and_return(list: nil, asdf: nil)
+      allow(helper).to receive_messages(blacklight_config: blacklight_config)
+      expect(helper.start_over_path(view: 'list')).to eq search_catalog_url
     end
   end
 
@@ -198,29 +198,37 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     let(:id) { '123456' }
     let(:data) { { 'id' => id, 'title_tsim' => [title_tsim] } }
     let(:document) { SolrDocument.new(data) }
+
     before do
       allow(controller).to receive(:action_name).and_return('index')
+      allow(helper.main_app).to receive(:track_test_path).and_return('tracking url')
+      allow(helper.main_app).to receive(:respond_to?).with('track_test_path').and_return(true)
     end
 
     it "consists of the document title wrapped in a <a>" do
-      expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", :text => '654321', :count => 1)
+      expect(Deprecation).to receive(:warn)
+      expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", text: '654321', count: 1)
     end
 
     it "accepts and returns a string label" do
-      expect(helper.link_to_document(document, String.new('title_tsim'))).to have_selector("a", :text => 'title_tsim', :count => 1)
+      expect(helper.link_to_document(document, 'This is the title')).to have_selector("a", text: 'This is the title', count: 1)
     end
 
     it "accepts and returns a Proc" do
-      expect(helper.link_to_document(document, Proc.new { |doc, opts| doc[:id] + ": " + doc.first(:title_tsim) })).to have_selector("a", :text => '123456: 654321', :count => 1)
+      expect(Deprecation).to receive(:warn).twice
+      expect(helper.link_to_document(document, proc { |doc, _opts| doc[:id] + ": " + doc.first(:title_tsim) })).to have_selector("a", text: '123456: 654321', count: 1)
     end
 
     context 'when label is missing' do
       let(:data) { { 'id' => id } }
+
       it "returns id" do
-        expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", :text => '123456', :count => 1)
+        expect(Deprecation).to receive(:warn)
+        expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", text: '123456', count: 1)
       end
 
       it "is html safe" do
+        expect(Deprecation).to receive(:warn)
         expect(helper.link_to_document(document, :title_tsim)).to be_html_safe
       end
 
@@ -229,11 +237,12 @@ RSpec.describe Blacklight::UrlHelperBehavior do
       end
 
       it "doesn't add an erroneous title attribute if one isn't provided" do
-        expect(helper.link_to_document(document, "Some crazy long label...")).to_not match(/title=/)
+        expect(helper.link_to_document(document, "Some crazy long label...")).not_to match(/title=/)
       end
 
       context "with an integer id" do
-        let(:id) { 123456 }
+        let(:id) { 123_456 }
+
         it "works" do
           expect(helper.link_to_document(document)).to have_selector("a")
         end
@@ -241,31 +250,27 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     end
 
     it "converts the counter parameter into a data- attribute" do
-      allow(helper).to receive(:track_test_path).with(hash_including(id: have_attributes(id: '123456'), counter: 5)).and_return('tracking url')
-
+      expect(Deprecation).to receive(:warn)
       expect(helper.link_to_document(document, :title_tsim, counter: 5)).to include 'data-context-href="tracking url"'
+      expect(helper.main_app).to have_received(:track_test_path).with(hash_including(id: have_attributes(id: '123456'), counter: 5))
     end
 
     it "includes the data- attributes from the options" do
-      link = helper.link_to_document document, { data: { x: 1 }  }
+      link = helper.link_to_document document, data: { x: 1 }
       expect(link).to have_selector '[data-x]'
     end
 
     it 'adds a controller-specific tracking attribute' do
-      expect(helper).to receive(:track_test_path).and_return('/asdf')
-      link = helper.link_to_document document, { data: { x: 1 }  }
+      expect(helper.main_app).to receive(:track_test_path).and_return('/asdf')
+      link = helper.link_to_document document, data: { x: 1 }
 
       expect(link).to have_selector '[data-context-href="/asdf"]'
     end
-
-    it 'adds a global tracking attribute' do
-      link = helper.link_to_document document, { data: { x: 1 }  }
-      expect(link).to have_selector '[data-context-href="/catalog/123456/track"]'
-    end
   end
 
   describe "link_to_previous_search" do
     let(:params) { {} }
+
     it "links to the given search parameters" do
       allow(helper).to receive(:render_search_to_s).with(params).and_return "link text"
       expect(helper.link_to_previous_search({})).to eq helper.link_to("link text", helper.search_action_path)
@@ -282,13 +287,14 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
   describe "#session_tracking_path" do
     let(:document) { SolrDocument.new(id: 1) }
+
     it "determines the correct route for the document class" do
-      allow(helper).to receive(:track_test_path).with(id: have_attributes(id: 1)).and_return('x')
+      allow(helper.main_app).to receive(:track_test_path).with(id: have_attributes(id: 1)).and_return('x')
       expect(helper.session_tracking_path(document)).to eq 'x'
     end
 
     it "passes through tracking parameters" do
-      allow(helper).to receive(:track_test_path).with(id: have_attributes(id: 1), x: 1).and_return('x')
+      allow(helper.main_app).to receive(:track_test_path).with(id: have_attributes(id: 1), x: 1).and_return('x')
       expect(helper.session_tracking_path(document, x: 1)).to eq 'x'
     end
   end