blacklight 6.19.1 → 7.1.0

data/spec/helpers/{hash_as_hidden_fields_spec.rb → blacklight/hash_as_hidden_fields_behavior_spec.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-describe Blacklight::HashAsHiddenFieldsHelperBehavior do
+RSpec.describe Blacklight::HashAsHiddenFieldsHelperBehavior do
   let(:params) do
     { q: "query",
       search_field: "search_field",
       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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::IconHelperBehavior do
+  describe '#blacklight_icon' do
+    it 'wraps the svg in a span with classes' do
+      expect(helper.blacklight_icon(:search))
+        .to have_css 'span.blacklight-icons svg'
+    end
+  end
+end

data/spec/helpers/{layout_helper_spec.rb → blacklight/layout_helper_behavior_spec.rb}

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-describe LayoutHelper do
+RSpec.describe Blacklight::LayoutHelperBehavior do
   describe '#show_content_classes' do
     it 'returns a string of classes' do
       expect(helper.show_content_classes).to be_an String
-      expect(helper.show_content_classes).to eq 'col-md-9 col-sm-8 show-document'
+      expect(helper.show_content_classes).to eq 'col-md-9 show-document'
     end
   end
 
   describe '#show_sidebar_classes' do
     it 'returns a string of classes' do
       expect(helper.show_sidebar_classes).to be_an String
-      expect(helper.show_sidebar_classes).to eq 'col-md-3 col-sm-4'
+      expect(helper.show_sidebar_classes).to eq 'page-sidebar col-md-3'
     end
   end
 
   describe '#main_content_classes' do
     it 'returns a string of classes' do
       expect(helper.main_content_classes).to be_an String
-      expect(helper.main_content_classes).to eq 'col-md-9 col-sm-8'
+      expect(helper.main_content_classes).to eq 'col-md-9'
     end
   end
 
   describe '#sidebar_classes' do
     it 'returns a string of classes' do
       expect(helper.sidebar_classes).to be_an String
-      expect(helper.sidebar_classes).to eq 'col-md-3 col-sm-4'
+      expect(helper.sidebar_classes).to eq 'page-sidebar col-md-3'
     end
   end
 

data/spec/helpers/{render_constraints_helper_spec.rb → blacklight/render_constraints_helper_behavior_spec.rb}

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-describe RenderConstraintsHelper do
-
+RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
   let(:config) do
     Blacklight::Configuration.new do |config|
       config.add_facet_field 'type'
@@ -17,9 +16,10 @@ describe RenderConstraintsHelper 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']"
@@ -35,6 +35,7 @@ describe RenderConstraintsHelper 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']"
@@ -43,18 +44,19 @@ describe RenderConstraintsHelper 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) }
 
     it "has a link relative to the current url" do
       expect(subject).to have_link "Remove constraint Item Type: journal", href: "/catalog?q=biz"
-      expect(subject).to have_selector ".filterName", text: 'Item Type'
+      expect(subject).to have_selector ".filter-name", text: 'Item Type'
     end
 
     context 'with string values' do
@@ -67,12 +69,14 @@ describe RenderConstraintsHelper 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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::RenderPartialsHelperBehavior do
+  describe "#type_field_to_partial_name" do
+    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) { %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')
+    end
+
+    it "gets the document format from document_partial_name" do
+      allow(helper).to receive(:document_partial_name).with(doc, :xyz)
+      helper.render_document_partial(doc, :xyz)
+    end
+  end
+
+  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' }
+
+      before do
+        blacklight_config.show.display_type_field = 'my_field'
+      end
+
+      it "uses the value in the configured display type field" do
+        expect(helper.document_partial_name(document)).to eq 'xyz'
+      end
+      it "uses the value in the configured display type field if the action-specific field is empty" do
+        expect(helper.document_partial_name(document, :some_action)).to eq 'xyz'
+      end
+    end
+
+    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/{search_history_constraints_helper_spec.rb → blacklight/search_history_constraints_helper_behavior_spec.rb}

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-describe SearchHistoryConstraintsHelper do
-
+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,32 +22,32 @@ describe SearchHistoryConstraintsHelper 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(span).to have_selector("span.filterName", :content => "key:")
-          expect(span).to have_selector("span.filterValue", :content => "value")
+        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
         expect(response).to be_html_safe
       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(span).to have_selector("span.filterName") do |s2|
+        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.filterValue") 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.filterName", :content => "key>:")
-          expect(span).to have_selector("span.filterValue", :content => "value>")
+          expect(span).to have_selector("span.filter-name", content: "key>:")
+          expect(span).to have_selector("span.filter-value", content: "value>")
         end
         expect(response).to be_html_safe
       end
@@ -56,30 +55,31 @@ describe SearchHistoryConstraintsHelper 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"]})
-        expect(response).to eq("<span class=\"constraint\"><span class=\"filterName\">Some:</span><span class=\"filterValues\"><span class=\"filterValue\">value1</span><span class=\"filterSeparator\"> and </span><span class=\"filterValue\">value2</span></span></span>")
+        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"]})
-        expect(response).to eq("<span class=\"constraint\"><span class=\"filterName\">#{'undefined_facet'.humanize}:</span><span class=\"filterValues\"><span class=\"filterValue\">value1</span><span class=\"filterSeparator\"> and </span><span class=\"filterValue\">value2</span></span></span>")
+        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
 
       context 'with I18n translations for selected facet' do
@@ -92,14 +92,13 @@ describe SearchHistoryConstraintsHelper 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/{suggest_helper_spec.rb → blacklight/suggest_helper_behavior_spec.rb}

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
-describe SuggestHelper do
+RSpec.describe Blacklight::SuggestHelperBehavior do
   before 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
@@ -12,10 +14,12 @@ describe SuggestHelper 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|
@@ -23,19 +27,22 @@ describe SuggestHelper 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
     end
   end
-end
+end

data/spec/helpers/{url_helper_spec.rb → blacklight/url_helper_behavior_spec.rb}

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-describe BlacklightUrlHelper do
-
+RSpec.describe Blacklight::UrlHelperBehavior do
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.index.title_field = 'title_display'
+      config.index.title_field = 'title_tsim'
       config.index.display_type_field = 'format'
     end
   end
@@ -37,7 +36,7 @@ describe BlacklightUrlHelper 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 @@ describe BlacklightUrlHelper 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 @@ describe BlacklightUrlHelper 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,38 +102,35 @@ describe BlacklightUrlHelper 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
-        if Rails.version >= '5.0.0'
-          controller.request.assign_parameters(Rails.application.routes, 'catalog', 'show', { id: '123' }, '/catalog/123', [:controller, :action, :id])
-        else
-          controller.request.assign_parameters(Rails.application.routes, 'catalog', 'show', id: '123')
-        end
+        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/
@@ -146,6 +141,7 @@ describe BlacklightUrlHelper 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
@@ -156,7 +152,7 @@ describe BlacklightUrlHelper 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
@@ -172,7 +168,7 @@ describe BlacklightUrlHelper 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
@@ -185,47 +181,55 @@ describe BlacklightUrlHelper 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
 
   describe "link_to_document" do
-    let(:title_display) { '654321' }
+    let(:title_tsim) { '654321' }
     let(:id) { '123456' }
-    let(:data) { { 'id' => id, 'title_display' => [title_display] } }
+    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_display)).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_display'))).to have_selector("a", :text => 'title_display', :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_display) })).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_display)).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(helper.link_to_document(document, :title_display)).to be_html_safe
+        expect(Deprecation).to receive(:warn)
+        expect(helper.link_to_document(document, :title_tsim)).to be_html_safe
       end
 
       it "passes on the title attribute to the link_to_with_data method" do
@@ -233,11 +237,12 @@ describe BlacklightUrlHelper 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
@@ -245,31 +250,27 @@ describe BlacklightUrlHelper 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(helper.link_to_document(document, :title_display, counter: 5)).to include 'data-context-href="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)
@@ -286,14 +287,20 @@ describe BlacklightUrlHelper 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
+
+    it "uses the track_search_session configuration to determine whether to track the search session" do
+      blacklight_config.track_search_session = false
+      expect(helper.session_tracking_path(document, x: 1)).to eq nil
+    end
   end
 end