blacklight 6.21.0 → 7.3.0

data/spec/helpers/blacklight_helper_spec.rb

@@ -1,19 +1,45 @@
 # frozen_string_literal: true
-describe BlacklightHelper do
-  before(:each) do
+RSpec.describe BlacklightHelper do
+  before do
     allow(helper).to receive(:current_or_guest_user).and_return(User.new)
     allow(helper).to receive(:search_action_path) do |*args|
       search_catalog_url *args
     end
   end
 
-  describe "#application_name", :test => true do
+  describe "#application_name" do
+    before do
+      allow(Rails).to receive(:cache).and_return(ActiveSupport::Cache::NullStore.new)
+    end
+
     it "defaults to 'Blacklight'" do
       expect(application_name).to eq "Blacklight"
     end
-    it "uses the Rails application config application_name if available" do
-      allow(Rails.application).to receive(:config).and_return(double(application_name: "asdf"))
-      expect(application_name).to eq "asdf"
+
+    context "when the language is not english " do
+      around do |example|
+        I18n.locale = :de
+        example.run
+        I18n.locale = :en
+      end
+
+      context "and no translation exists for that language" do
+        it "defaults to 'Blacklight'" do
+          expect(application_name).to eq "Blacklight"
+        end
+      end
+
+      context "and a translation exists for that language" do
+        around do |example|
+          I18n.backend.store_translations(:de, 'blacklight' => { 'application_name' => 'Schwarzlicht' })
+          example.run
+          I18n.backend.reload!
+        end
+
+        it "uses the provided value" do
+          expect(application_name).to eq "Schwarzlicht"
+        end
+      end
     end
   end
 
@@ -34,10 +60,11 @@ describe BlacklightHelper do
   describe "render_link_rel_alternates" do
     let(:document) { instance_double(SolrDocument) }
     let(:result) { double }
-    let(:presenter) { Blacklight::DocumentPresenter.new(document, self) }
+    let(:view_context) { double(blacklight_config: blacklight_config, document_index_view_type: 'index') }
+    let(:presenter) { Blacklight::IndexPresenter.new(document, view_context) }
     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
@@ -61,11 +88,11 @@ describe BlacklightHelper do
   describe "with a config" do
     let(: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
-    let(:document) { SolrDocument.new('title_display' => "A Fake Document", 'id'=>'8') }
+    let(:document) { SolrDocument.new('title_tsim' => "A Fake Document", 'id' => '8') }
 
     before do
       config.add_show_tools_partial(:bookmark, partial: 'catalog/bookmark_control')
@@ -78,7 +105,7 @@ describe BlacklightHelper do
     describe "render_nav_actions" do
       it "renders partials" do
         buff = String.new
-        helper.render_nav_actions { |config, item| buff << "<foo>#{item}</foo>" }
+        helper.render_nav_actions { |_config, item| buff << "<foo>#{item}</foo>" }
         expect(buff).to have_selector "foo a#bookmarks_nav[href=\"/bookmarks\"]"
         expect(buff).to have_selector "foo a span[data-role='bookmark-counter']", text: '0'
       end
@@ -88,7 +115,7 @@ describe BlacklightHelper do
       it "renders partials" do
         allow(controller).to receive(:render_bookmarks_control?).and_return(true)
         response = helper.render_index_doc_actions(document)
-        expect(response).to have_selector(".bookmark_toggle")
+        expect(response).to have_selector(".bookmark-toggle")
       end
 
       it "is nil if no partials are renderable" do
@@ -106,7 +133,7 @@ describe BlacklightHelper do
     describe "render_show_doc_actions" do
       it "renders partials" do
         response = helper.render_show_doc_actions(document)
-        expect(response).to have_selector(".bookmark_toggle")
+        expect(response).to have_selector(".bookmark-toggle")
       end
     end
   end
@@ -117,15 +144,18 @@ describe BlacklightHelper do
     end
 
     it "is true" do
+      expect(Deprecation).to receive(:warn)
       expect(helper.should_render_index_field?(double, double)).to be true
     end
 
     it "is false if the document doesn't have a value for the field" do
+      expect(Deprecation).to receive(:warn)
       allow(helper).to receive_messages(document_has_value?: false)
       expect(helper.should_render_index_field?(double, double)).to be false
     end
 
     it "is false if the configuration has the field disabled" do
+      expect(Deprecation).to receive(:warn)
       allow(helper).to receive_messages(should_render_field?: false)
       expect(helper.should_render_index_field?(double, double)).to be false
     end
@@ -137,81 +167,43 @@ describe BlacklightHelper do
     end
 
     it "is true" do
+      expect(Deprecation).to receive(:warn)
       expect(helper.should_render_show_field?(double, double)).to be true
     end
 
     it "is false if the document doesn't have a value for the field" do
+      expect(Deprecation).to receive(:warn)
       allow(helper).to receive_messages(document_has_value?: false)
       expect(helper.should_render_show_field?(double, double)).to be false
     end
 
     it "is false if the configuration has the field disabled" do
+      expect(Deprecation).to receive(:warn)
       allow(helper).to receive_messages(should_render_field?: false)
       expect(helper.should_render_show_field?(double, double)).to be false
     end
   end
 
-  context "render methods" do
-    let(:field) { "some_field" }
-    let(:doc) { instance_double(SolrDocument) }
-    let(:presenter) { instance_double(Blacklight::ShowPresenter) }
-    before do
-      allow(Deprecation).to receive(:warn) # TODO: purge Deprecations
-      allow(helper).to receive(:presenter).with(doc).and_return(presenter)
-    end
-
-    describe "#render_index_field_value" do
-      it "passes the document and field through to the presenter" do
-        expect(presenter).to receive(:field_value).with(field, {})
-        helper.render_index_field_value(doc, field)
-      end
-
-      it "allows the document and field to be passed as hash arguments" do
-        expect(presenter).to receive(:field_value).with(field, {})
-        helper.render_index_field_value(document: doc, field: field)
-      end
-
-      it "allows additional options to be passed to the presenter" do
-        expect(presenter).to receive(:field_value).with(field, x: 1)
-        helper.render_index_field_value(document: doc, field: field, x: 1)
-      end
-    end
-
-    describe "#render_document_show_field_value" do
-      it "passes the document and field through to the presenter" do
-        expect(presenter).to receive(:field_value).with(field, {})
-        helper.render_document_show_field_value(doc, field)
-      end
-
-      it "allows the document and field to be passed as hash arguments" do
-        expect(presenter).to receive(:field_value).with(field, {})
-        helper.render_document_show_field_value(document: doc, field: field)
-      end
-
-      it "allows additional options to be passed to the presenter" do
-        expect(presenter).to receive(:field_value).with(field, x: 1)
-        helper.render_document_show_field_value(document: doc, field: field, x: 1)
-      end
-    end
-  end
-
   describe "#document_has_value?" do
     let(:doc) { double(SolrDocument) }
+
+    before { allow(Deprecation).to receive(:warn) }
+
     it "ifs the document has the field value" do
       allow(doc).to receive(:has?).with('asdf').and_return(true)
-      field_config = double(:field => 'asdf')
+      field_config = double(field: 'asdf')
       expect(helper.document_has_value?(doc, field_config)).to eq true
     end
     it "ifs the document has a highlight field value" do
       allow(doc).to receive(:has?).with('asdf').and_return(false)
       allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
-      field_config = double(:field => 'asdf', :highlight => true)
+      field_config = double(field: 'asdf', highlight: true)
       expect(helper.document_has_value?(doc, field_config)).to eq true
     end
     it "ifs the field has a model accessor" do
       allow(doc).to receive(:has?).with('asdf').and_return(false)
       allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(false)
-      field_config = double(:field => 'asdf', :highlight => true, :accessor => true)
+      field_config = double(field: 'asdf', highlight: true, accessor: true)
       expect(helper.document_has_value?(doc, field_config)).to eq true
     end
   end
@@ -236,99 +228,28 @@ describe BlacklightHelper do
     before do
       allow(helper).to receive_messages spell_check_max: 5
     end
+
     it "does not show suggestions if there are enough results" do
       response = double(total: 10)
-      expect(helper.should_show_spellcheck_suggestions? response).to be false
+      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
     end
     it "only shows suggestions if there are very few results" do
       response = double(total: 4, spelling: double(words: [1]))
-      expect(helper.should_show_spellcheck_suggestions? response).to be true
+      expect(helper.should_show_spellcheck_suggestions?(response)).to be true
     end
     it "shows suggestions only if there are spelling suggestions available" do
       response = double(total: 4, spelling: double(words: []))
-      expect(helper.should_show_spellcheck_suggestions? response).to be false
+      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
     end
     it "does not show suggestions if spelling is not available" do
       response = double(total: 4, spelling: nil)
-      expect(helper.should_show_spellcheck_suggestions? response).to be false
-    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
-
-  describe "#type_field_to_partial_name" do
-    let(:document) { double }
-    context "with default value" do
-      subject { helper.type_field_to_partial_name(document, 'default') }
-      it { should eq 'default' }
-    end
-    context "with spaces" do
-      subject { helper.type_field_to_partial_name(document, 'one two three') }
-      it { should eq 'one_two_three' }
-    end
-    context "with hyphens" do
-      subject { helper.type_field_to_partial_name(document, 'one-two-three') }
-      it { should eq 'one_two_three' }
-    end
-    context "an array" do
-      subject { helper.type_field_to_partial_name(document, ['one', 'two', 'three']) }
-      it { should eq 'one_two_three' }
+      expect(helper.should_show_spellcheck_suggestions?(response)).to be false
     end
   end
 
   describe "#opensearch_description_tag" do
     subject { helper.opensearch_description_tag 'title', 'href' }
+
     it "has a search rel" do
       expect(subject).to have_selector "link[rel='search']", visible: false
     end
@@ -353,6 +274,7 @@ describe BlacklightHelper do
 
   describe "#render_document_index_with_view" do
     let(:obj1) { SolrDocument.new }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
       assign(:response, instance_double(Blacklight::Solr::Response, grouped?: false, start: 0))
@@ -413,23 +335,11 @@ describe BlacklightHelper do
   context "related classes" do
     let(:presenter_class) { double }
     let(:blacklight_config) { Blacklight::Configuration.new }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
     end
 
-    describe "#presenter_class" do
-      it "uses the value defined in the blacklight configuration" do
-        expect(Deprecation).to receive(:warn).exactly(2).times
-        blacklight_config.document_presenter_class = presenter_class
-        expect(helper.presenter_class).to eq presenter_class
-      end
-
-      it "defaults to Blacklight::DocumentPresenter" do
-        expect(Deprecation).to receive(:warn)
-        expect(helper.presenter_class).to eq Blacklight::DocumentPresenter
-      end
-    end
-
     describe "#index_presenter_class" do
       it "uses the value defined in the blacklight configuration" do
         blacklight_config.index.document_presenter_class = presenter_class
@@ -455,6 +365,7 @@ describe BlacklightHelper do
 
   describe "#render_document_heading" do
     let(:document) { double }
+
     before do
       allow(helper).to receive(:presenter).and_return(double(heading: "Heading"))
     end
@@ -464,7 +375,7 @@ describe BlacklightHelper do
     end
 
     it "accepts the tag name as an option" do
-      expect(helper.render_document_heading tag: "h1").to have_selector "h1", text: "Heading"
+      expect(helper.render_document_heading(tag: "h1")).to have_selector "h1", text: "Heading"
     end
 
     it "accepts an explicit document argument" do
@@ -477,4 +388,46 @@ describe BlacklightHelper do
       expect(helper.render_document_heading(document, tag: "h3")).to have_selector "h3", text: "Document Heading"
     end
   end
+
+  describe "#presenter" do
+    let(:document) { double }
+
+    before do
+      allow(helper).to receive(:index_presenter).and_return(:index_presenter)
+      allow(helper).to receive(:show_presenter).and_return(:show_presenter)
+      allow(helper).to receive(:action_name).and_return(action_name)
+    end
+
+    context "action is show" do
+      let(:action_name) { "show" }
+
+      it "uses the show presenter" do
+        expect(helper.presenter(document)).to eq(:show_presenter)
+      end
+    end
+
+    context "action is citation" do
+      let(:action_name) { "citation" }
+
+      it "uses the show presenter" do
+        expect(helper.presenter(document)).to eq(:show_presenter)
+      end
+    end
+
+    context "action is index" do
+      let(:action_name) { "index" }
+
+      it "uses the index presenter" do
+        expect(helper.presenter(document)).to eq(:index_presenter)
+      end
+    end
+
+    context "action is foo" do
+      let(:action_name) { "foo" }
+
+      it "uses the index presenter (by default)" do
+        expect(helper.presenter(document)).to eq(:index_presenter)
+      end
+    end
+  end
 end

data/spec/helpers/catalog_helper_spec.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-describe CatalogHelper do
+RSpec.describe CatalogHelper do
   include ERB::Util
-  include CatalogHelper
+  include described_class
 
   def mock_response args
     current_page = args[:current_page] || 1
@@ -22,18 +22,17 @@ describe CatalogHelper do
     false
   end
 
-
   describe "page_entries_info" do
     it "with no results" do
-      @response = mock_response :total => 0
+      @response = mock_response total: 0
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "No entry_names found"
       expect(html).to be_html_safe
     end
 
     it "with no results (and no entry_name provided)" do
-      @response = mock_response :total => 0
+      @response = mock_response total: 0
 
       html = page_entries_info(@response)
       expect(html).to eq "No entries found"
@@ -49,81 +48,74 @@ describe CatalogHelper do
 
     describe "with a single result" do
       it "uses the provided entry name" do
-        response = mock_response :total => 1
+        response = mock_response total: 1
 
-        html = page_entries_info(response, { :entry_name => 'entry_name' })
+        html = page_entries_info(response, entry_name: 'entry_name')
         expect(html).to eq "<strong>1</strong> entry_name found"
         expect(html).to be_html_safe
       end
 
       it "infers a name" do
-        response = mock_response :total => 1
+        response = mock_response total: 1
 
         html = page_entries_info(response)
         expect(html).to eq "<strong>1</strong> entry found"
         expect(html).to be_html_safe
       end
-
-      it "uses the model_name from the response" do
-        response = mock_response :total => 1
-        allow(response).to receive(:model_name).and_return(double(:human => 'thingy'))
-
-        html = page_entries_info(response)
-        expect(html).to eq "<strong>1</strong> thingy found"
-        expect(html).to be_html_safe
-      end
     end
 
     it "with a single page of results" do
-      response = mock_response :total => 7
+      response = mock_response total: 7
 
-      html = page_entries_info(response, { :entry_name => 'entry_name' })
+      html = page_entries_info(response, entry_name: 'entry_name')
       expect(html).to eq "<strong>1</strong> - <strong>7</strong> of <strong>7</strong>"
       expect(html).to be_html_safe
     end
 
     it "on the first page of multiple pages of results" do
-      @response = mock_response :total => 15, :per_page => 10
+      @response = mock_response total: 15, per_page: 10
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "<strong>1</strong> - <strong>10</strong> of <strong>15</strong>"
       expect(html).to be_html_safe
     end
 
     it "on the second page of multiple pages of results" do
-      @response = mock_response :total => 47, :per_page => 10, :current_page => 2
+      @response = mock_response total: 47, per_page: 10, current_page: 2
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "<strong>11</strong> - <strong>20</strong> of <strong>47</strong>"
       expect(html).to be_html_safe
     end
 
     it "on the last page of results" do
-      @response = mock_response :total => 47, :per_page => 10, :current_page => 5
+      @response = mock_response total: 47, per_page: 10, current_page: 5
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "<strong>41</strong> - <strong>47</strong> of <strong>47</strong>"
       expect(html).to be_html_safe
     end
     it "works with rows the same as per_page" do
-      @response = mock_response :total => 47, :rows => 20, :current_page => 2
+      @response = mock_response total: 47, rows: 20, current_page: 2
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "<strong>21</strong> - <strong>40</strong> of <strong>47</strong>"
       expect(html).to be_html_safe
     end
 
     it "uses delimiters with large numbers" do
-      @response = mock_response :total => 5000, :rows => 10, :current_page => 101
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      @response = mock_response total: 5000, rows: 10, current_page: 101
+      html = page_entries_info(@response, entry_name: 'entry_name')
 
       expect(html).to eq "<strong>1,001</strong> - <strong>1,010</strong> of <strong>5,000</strong>"
     end
 
     context "with an ActiveRecord collection" do
+      subject { helper.page_entries_info(Bookmark.page(1).per(25)) }
+
       let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345' }
+
       before { 50.times { Bookmark.create!(user: user) } }
-      subject { helper.page_entries_info(Bookmark.page(1).per(25)) }
 
       it { is_expected.to eq "<strong>1</strong> - <strong>25</strong> of <strong>50</strong>" }
     end
@@ -174,6 +166,10 @@ describe CatalogHelper do
   end
 
   describe "should_autofocus_on_search_box?" do
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
     it "is focused if we're on a catalog-like index page without query or facet parameters" do
       allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: false)
       expect(helper.should_autofocus_on_search_box?).to be true
@@ -196,102 +192,81 @@ describe CatalogHelper do
   end
 
   describe "has_thumbnail?" do
-    let(:document) { instance_double(SolrDocument) }
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
+    let(:document) { SolrDocument.new(data) }
+    let(:data) { {} }
+
     it "has a thumbnail if a thumbnail_method is configured" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      expect(helper.has_thumbnail? document).to be true
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_method: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
+      expect(helper.has_thumbnail?(document)).to be true
     end
 
-    it "has a thumbnail if a thumbnail_field is configured and it exists in the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-      allow(document).to receive_messages(has?: true)
-      expect(helper.has_thumbnail? document).to be true
+    context "if a thumbnail_field is configured and it exists in the document" do
+      let(:data) { { xyz: 'abc' } }
+
+      it "has a thumbnail" do
+        allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
+        expect(helper.has_thumbnail?(document)).to be true
+      end
     end
-    
+
     it "does not have a thumbnail if the thumbnail_field is missing from the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
       allow(document).to receive_messages(has?: false)
-      expect(helper.has_thumbnail? document).to be false
+      expect(helper.has_thumbnail?(document)).to be false
     end
 
     it "does not have a thumbnail if none of the fields are configured" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
-      expect(helper.has_thumbnail? document).to be_falsey
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(document_presenter_class: Blacklight::IndexPresenter)))
+      expect(helper).not_to have_thumbnail(document)
     end
   end
 
   describe "render_thumbnail_tag" do
-    let(:document) { instance_double(SolrDocument) }
-    it "calls the provided thumbnail method" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      expect(helper).to receive_messages(:xyz => "some-thumbnail")
-
-      allow(helper).to receive(:link_to_document).with(document, "some-thumbnail", {})
-      helper.render_thumbnail_tag document
+    let(:index_presenter) do
+      instance_double(Blacklight::IndexPresenter, thumbnail: thumbnail_presenter)
     end
+    let(:thumbnail_presenter) { instance_double(Blacklight::ThumbnailPresenter) }
 
-    it "creates an image tag from the given field" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-
-      allow(document).to receive(:has?).with(:xyz).and_return(true)
-      allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
-
-      expect(helper).to receive(:link_to_document).with(document, image_tag("http://example.com/some.jpg"), {})
-      helper.render_thumbnail_tag document
-    end
-
-    it "does not link to the document if the url options are false" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => "some-thumbnail")
+    before do
       expect(Deprecation).to receive(:warn)
-      result = helper.render_thumbnail_tag document, {}, false
-      expect(result).to eq "some-thumbnail"
-    end
-
-    it "does not link to the document if the url options have :suppress_link" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => "some-thumbnail")
-
-      result = helper.render_thumbnail_tag document, {}, suppress_link: true
-      expect(result).to eq "some-thumbnail"
+      allow(helper).to receive(:index_presenter).with(document).and_return(index_presenter)
     end
 
+    let(:document) { instance_double(SolrDocument) }
 
-    it "returns nil if no thumbnail is available" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
-      expect(helper.render_thumbnail_tag document).to be_nil
-    end
-
-    it "returns nil if no thumbnail is returned from the thumbnail method" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => nil)
-
-      expect(helper.render_thumbnail_tag document).to be_nil
+    it "calls thumbnail presenter with default values" do
+      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, {})
+      helper.render_thumbnail_tag document
     end
 
-    it "returns nil if no thumbnail is in the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-
-      allow(document).to receive(:has?).with(:xyz).and_return(false)
-
-      expect(helper.render_thumbnail_tag document).to be_nil
+    it "calls thumbnail presenter with provided values" do
+      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, suppress_link: true)
+      helper.render_thumbnail_tag document, {}, suppress_link: true
     end
   end
 
   describe "thumbnail_url" do
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
     it "pulls the configured thumbnail field out of the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
       document = instance_double(SolrDocument)
       allow(document).to receive(:has?).with(:xyz).and_return(true)
       allow(document).to receive(:first).with(:xyz).and_return("asdf")
-      expect(helper.thumbnail_url document).to eq("asdf")
+      expect(helper.thumbnail_url(document)).to eq("asdf")
     end
 
     it "returns nil if the thumbnail field doesn't exist" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
       document = instance_double(SolrDocument)
       allow(document).to receive(:has?).with(:xyz).and_return(false)
-      expect(helper.thumbnail_url document).to be_nil
+      expect(helper.thumbnail_url(document)).to be_nil
     end
   end
 
@@ -325,38 +300,37 @@ describe CatalogHelper do
 
     it "pulls data out of a document's field" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => 'book' }
+      doc = { type: 'book' }
       expect(helper.render_document_class(doc)).to eq "blacklight-book"
     end
 
     it "supports multivalued fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => ['book', 'mss'] }
+      doc = { type: %w[book mss] }
       expect(helper.render_document_class(doc)).to eq "blacklight-book blacklight-mss"
     end
 
     it "supports empty fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => [] }
+      doc = { type: [] }
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports missing fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { }
+      doc = {}
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports view-specific field configuration" do
       allow(helper).to receive(:document_index_view_type).and_return(:some_view_type)
       blacklight_config.view.some_view_type.display_type_field = :other_type
-      doc = { other_type: "document"}
+      doc = { other_type: "document" }
       expect(helper.render_document_class(doc)).to eq "blacklight-document"
     end
   end
 
   describe "#bookmarked?" do
-
     let(:bookmark) { Bookmark.new document: bookmarked_document }
     let(:bookmarked_document) { SolrDocument.new(id: 'a') }
 
@@ -387,25 +361,35 @@ describe CatalogHelper do
     end
 
     it "renders a facet with two values" do
-      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz'])).to eq "Foo: bar and baz"
+      expect(helper.render_search_to_page_title_filter('foo', %w[bar baz])).to eq "Foo: bar and baz"
     end
 
     it "renders a facet with more than two values" do
-      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz', 'foobar'])).to eq "Foo: 3 selected"
+      expect(helper.render_search_to_page_title_filter('foo', %w[bar baz foobar])).to eq "Foo: 3 selected"
     end
   end
 
   describe "#render_search_to_page_title" do
+    subject { helper.render_search_to_page_title(params) }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(blacklight_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('')
     end
 
     let(:blacklight_config) { Blacklight::Configuration.new }
-    let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: ["Book"] }) }
-    subject { helper.render_search_to_page_title(params) }
 
-    it { is_expected.to eq "foobar / Format: Book" }
+    context 'when the f param is an array' do
+      let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: ["Book"] }) }
+
+      it { is_expected.to eq "foobar / Format: Book" }
+    end
+
+    context 'when the f param is not an array' do
+      let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: 'Book' }) }
+
+      it { is_expected.to eq "foobar / Format: Book" }
+    end
   end
 end