blacklight 7.41.0 → 8.0.0.beta1

data/spec/helpers/blacklight/url_helper_behavior_spec.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::UrlHelperBehavior do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
       config.index.title_field = 'title_tsim'
@@ -14,6 +12,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
   before do
     allow(controller).to receive(:controller_name).and_return('test')
+    allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
     allow(helper).to receive(:search_action_path) do |*args|
       search_catalog_url *args
     end
@@ -23,54 +22,6 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     allow(helper).to receive(:search_session).and_return({})
   end
 
-  describe "url_for_document" do
-    let(:controller_class) { ::CatalogController.new }
-    let(:doc) { SolrDocument.new }
-
-    before do
-      allow(helper).to receive_messages(controller: controller_class)
-      allow(helper).to receive_messages(controller_name: controller_class.controller_name)
-      allow(helper).to receive_messages(params: parameter_class.new)
-    end
-
-    it "is a polymorphic routing-ready object" do
-      expect(helper.url_for_document(doc)).to eq doc
-    end
-
-    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)
-    end
-
-    context "within bookmarks" do
-      let(:controller_class) { ::BookmarksController.new }
-
-      it "uses polymorphic routing" do
-        expect(helper.url_for_document(doc)).to eq doc
-      end
-    end
-
-    context "within an alternative catalog controller" do
-      let(:controller_class) { ::AlternateController.new }
-
-      before do
-        helper.blacklight_config.show.route = { controller: :current }
-        allow(helper).to receive(:params).and_return(parameter_class.new(controller: 'alternate'))
-      end
-
-      it "supports the :current controller configuration" do
-        expect(helper.url_for_document(doc)).to eq(controller: 'alternate', action: :show, id: doc)
-      end
-    end
-
-    it "is a polymorphic route if the solr document responds to #to_model with a non-SolrDocument" do
-      some_model = double
-      doc = SolrDocument.new
-      allow(doc).to receive_messages(to_model: some_model)
-      expect(helper.url_for_document(doc)).to eq doc
-    end
-  end
-
   describe "link_back_to_catalog" do
     let(:query_params) { { q: "query", f: "facets", controller: 'catalog' } }
     let(:bookmarks_query_params) { { controller: 'bookmarks' } }
@@ -148,61 +99,6 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     end
   end
 
-  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
-
-  describe "link_to_query" do
-    it "builds a link tag to catalog using query string (no other params)" do
-      query = "brilliant"
-      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 %r{>#{query}</a>}
-    end
-
-    it "builds a link tag to catalog using query string and other existing params" do
-      query = "wonderful"
-      allow(helper).to receive_messages(params: parameter_class.new(qt: "title_search", per_page: "50"))
-      tag = helper.link_to_query(query)
-      expect(tag).to match /qt=title_search/
-      expect(tag).to match /per_page=50/
-    end
-
-    it "ignores existing :page param" do
-      query = "yes"
-      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).not_to match /page/
-    end
-
-    it "is html_safe" do
-      query = "brilliant"
-      allow(helper).to receive_messages(params: parameter_class.new(page: "2", qt: "author_search"))
-      tag = helper.link_to_query(query)
-      expect(tag).to be_html_safe
-    end
-  end
-
-  describe "start_over_path" do
-    it 'is the catalog path with the current view type' do
-      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).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_tsim) { '654321' }
     let(:id) { '123456' }
@@ -216,30 +112,22 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     end
 
     it "consists of the document title wrapped in a <a>" do
-      allow(Deprecation).to receive(:warn)
-      expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", text: '654321', count: 1)
+      expect(helper.link_to_document(document)).to have_selector("a", text: '654321', count: 1)
     end
 
     it "accepts and returns a string label" do
       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
-      allow(Deprecation).to receive(:warn)
-      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
-        allow(Deprecation).to receive(:warn)
-        expect(helper.link_to_document(document, :title_tsim)).to have_selector("a", text: '123456', count: 1)
+        expect(helper.link_to_document(document)).to have_selector("a", text: '123456', count: 1)
       end
 
       it "is html safe" do
-        allow(Deprecation).to receive(:warn)
-        expect(helper.link_to_document(document, :title_tsim)).to be_html_safe
+        expect(helper.link_to_document(document)).to be_html_safe
       end
 
       it "passes on the title attribute to the link_to_with_data method" do
@@ -253,15 +141,14 @@ RSpec.describe Blacklight::UrlHelperBehavior do
       context "with an integer id" do
         let(:id) { 123_456 }
 
-        it "works" do
+        it "has a link" do
           expect(helper.link_to_document(document)).to have_selector("a")
         end
       end
     end
 
     it "converts the counter parameter into a data- attribute" do
-      allow(Deprecation).to receive(:warn)
-      expect(helper.link_to_document(document, :title_tsim, counter: 5)).to include 'data-context-href="tracking url"'
+      expect(helper.link_to_document(document, 'foo', 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
 
@@ -279,19 +166,10 @@ RSpec.describe Blacklight::UrlHelperBehavior do
   end
 
   describe "link_to_previous_search" do
-    let(:params) { {} }
+    let(:params) { { q: 'search query' } }
 
     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)
-    end
-  end
-
-  describe "#bookmarks_export_url" do
-    it "is the bookmark url with an encrypted user token" do
-      allow(helper).to receive_messages(encrypt_user_id: 'xyz', current_or_guest_user: double(id: 123))
-      url = helper.bookmarks_export_url(:html)
-      expect(url).to eq helper.bookmarks_url(format: :html, encrypted_user_id: 'xyz')
+      expect(helper.link_to_previous_search(params)).to have_link(href: helper.search_action_path(params)).and(have_text('search query'))
     end
   end
 
@@ -310,7 +188,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
     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
+      expect(helper.session_tracking_path(document, x: 1)).to be_nil
     end
   end
 end

data/spec/helpers/blacklight_helper_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 RSpec.describe BlacklightHelper do
   before do
     allow(helper).to receive(:current_or_guest_user).and_return(User.new)
@@ -16,7 +17,7 @@ RSpec.describe BlacklightHelper do
       expect(application_name).to eq "Blacklight"
     end
 
-    context "when the language is not english " do
+    context "when the language is not english" do
       around do |example|
         I18n.locale = :de
         example.run
@@ -72,7 +73,7 @@ RSpec.describe BlacklightHelper do
     end
 
     before do
-      allow(helper).to receive(:presenter).and_return(presenter)
+      allow(helper).to receive(:document_presenter).and_return(presenter)
       allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
     end
 
@@ -131,104 +132,6 @@ RSpec.describe BlacklightHelper do
         expect(helper.render_index_doc_actions(document)).to be_blank
       end
     end
-
-    describe "render_show_doc_actions" do
-      it "renders partials" do
-        response = helper.render_show_doc_actions(document)
-        expect(response).to have_selector(".bookmark-toggle")
-      end
-    end
-  end
-
-  describe "#should_render_index_field?" do
-    before do
-      allow(helper).to receive_messages(should_render_field?: true, document_has_value?: true)
-    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
-  end
-
-  describe "#should_render_show_field?" do
-    before do
-      allow(helper).to receive_messages(should_render_field?: true, document_has_value?: true)
-    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
-
-  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')
-      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)
-      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)
-      expect(helper.document_has_value?(doc, field_config)).to eq true
-    end
-  end
-
-  describe '#render_index_field_label' do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    let(:doc) { SolrDocument.new({}) }
-
-    before do
-      allow(helper).to receive_messages(document_index_view_type: :current_view)
-    end
-
-    it 'accepts an explicit field label' do
-      expect(helper.render_index_field_label(doc, field: 'xyz', label: 'some label')).to eq 'some label:'
-    end
-
-    it 'calculates the appropriate field label for a field' do
-      allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
-      expect(helper.render_index_field_label(doc, field: 'xyz')).to eq 'Xyz:'
-    end
   end
 
   describe "render_grouped_response?" do
@@ -243,43 +146,6 @@ RSpec.describe BlacklightHelper do
     end
   end
 
-  describe "render_grouped_document_index" do
-    pending 'not implemented'
-  end
-
-  describe "should_show_spellcheck_suggestions?" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    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
-    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
-    end
-
-    it "only shows suggestions from collations" do
-      response = double(total: 4, spelling: double(words: [], collation: { blah: 1 }))
-      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: [], collation: nil))
-      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 "#opensearch_description_tag" do
     subject { helper.opensearch_description_tag 'title', 'href' }
 
@@ -331,17 +197,12 @@ RSpec.describe BlacklightHelper do
         blacklight_config.view.gallery(template: '/my/partial')
       end
 
+      def stub_template(hash)
+        view.view_paths.unshift(ActionView::FixtureResolver.new(hash))
+      end
+
       it 'renders that template' do
-        # Not sure why we need to re-implement rspec's stub_template, but
-        # we already were, and need a Rails 7.1+ safe alternate too
-        # https://github.com/rspec/rspec-rails/commit/4d65bea0619955acb15023b9c3f57a3a53183da8
-        # https://github.com/rspec/rspec-rails/issues/2696
-        replace_hash = { 'my/_partial.html.erb' => 'some content' }
-        if ::Rails.version.to_f >= 7.1
-          controller.prepend_view_path(RSpec::Rails::ViewExampleGroup::StubResolverCache.resolver_for(replace_hash))
-        else
-          view.view_paths.unshift(ActionView::FixtureResolver.new(replace_hash))
-        end
+        stub_template 'my/_partial.html.erb' => 'some content'
 
         response = helper.render_document_index_with_view :gallery, [obj1, obj1]
 
@@ -393,109 +254,4 @@ RSpec.describe BlacklightHelper do
       end
     end
   end
-
-  context "related classes" do
-    let(:presenter_class) { double }
-    let(:blacklight_config) { Blacklight::Configuration.new }
-
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    before do
-      allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-    end
-
-    describe "#index_presenter_class" do
-      it "uses the value defined in the blacklight configuration" do
-        blacklight_config.index.document_presenter_class = presenter_class
-        expect(helper.index_presenter_class(nil)).to eq presenter_class
-      end
-
-      it "defaults to Blacklight::IndexPresenter" do
-        expect(helper.index_presenter_class(nil)).to eq Blacklight::IndexPresenter
-      end
-    end
-
-    describe "#show_presenter_class" do
-      it "uses the value defined in the blacklight configuration" do
-        blacklight_config.show.document_presenter_class = presenter_class
-        expect(helper.show_presenter_class(nil)).to eq presenter_class
-      end
-
-      it "defaults to Blacklight::DocumentPresenter" do
-        expect(helper.show_presenter_class(nil)).to eq Blacklight::ShowPresenter
-      end
-    end
-  end
-
-  describe "#render_document_heading" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    let(:document) { double }
-
-    before do
-      allow(helper).to receive(:presenter).and_return(double(heading: "Heading"))
-    end
-
-    it "accepts no arguments and render the document heading" do
-      expect(helper.render_document_heading).to have_selector "h4", text: "Heading"
-    end
-
-    it "accepts the tag name as an option" do
-      expect(helper.render_document_heading(tag: "h1")).to have_selector "h1", text: "Heading"
-    end
-
-    it "accepts an explicit document argument" do
-      allow(helper).to receive(:presenter).with(document).and_return(double(heading: "Document Heading"))
-      expect(helper.render_document_heading(document)).to have_selector "h4", text: "Document Heading"
-    end
-
-    it "accepts the document with a tag option" do
-      allow(helper).to receive(:presenter).with(document).and_return(double(heading: "Document Heading"))
-      expect(helper.render_document_heading(document, tag: "h3")).to have_selector "h3", text: "Document Heading"
-    end
-  end
-
-  describe "#presenter" do
-    around { |test| Deprecation.silence(Blacklight::BlacklightHelperBehavior) { test.call } }
-
-    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

@@ -164,111 +164,6 @@ RSpec.describe CatalogHelper do
     end
   end
 
-  describe "should_autofocus_on_search_box?" do
-    before do
-      allow(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
-    end
-
-    it "does not be focused if we're not on a catalog controller" do
-      allow(helper).to receive_messages(controller: ApplicationController.new)
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-
-    it "does not be focused if we're not on a catalog controller index" do
-      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "show")
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-
-    it "does not be focused if a search parameters are provided" do
-      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: true)
-      expect(helper.should_autofocus_on_search_box?).to be false
-    end
-  end
-
-  describe "has_thumbnail?" do
-    before do
-      allow(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, document_presenter_class: Blacklight::IndexPresenter)))
-      expect(helper.has_thumbnail?(document)).to be true
-    end
-
-    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, document_presenter_class: Blacklight::IndexPresenter)))
-      allow(document).to receive_messages(has?: 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(document_presenter_class: Blacklight::IndexPresenter)))
-      expect(helper).not_to have_thumbnail(document)
-    end
-  end
-
-  describe "render_thumbnail_tag" do
-    let(:index_presenter) do
-      instance_double(Blacklight::IndexPresenter, thumbnail: thumbnail_presenter)
-    end
-    let(:thumbnail_presenter) { instance_double(Blacklight::ThumbnailPresenter) }
-
-    before do
-      allow(Deprecation).to receive(:warn)
-      allow(helper).to receive(:index_presenter).with(document).and_return(index_presenter)
-    end
-
-    let(:document) { instance_double(SolrDocument) }
-
-    it "calls thumbnail presenter with default values" do
-      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, {})
-      helper.render_thumbnail_tag document
-    end
-
-    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
-      allow(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)))
-      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")
-    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)))
-      document = instance_double(SolrDocument)
-      allow(document).to receive(:has?).with(:xyz).and_return(false)
-      expect(helper.thumbnail_url(document)).to be_nil
-    end
-  end
-
   describe "document_counter_with_offset" do
     it "renders the document index with the appropriate offset" do
       assign(:response, instance_double(Blacklight::Solr::Response, start: 0, grouped?: false))
@@ -299,32 +194,32 @@ RSpec.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' }.with_indifferent_access
       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: %w[book mss] }
+      doc = { type: %w[book mss] }.with_indifferent_access
       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: [] }.with_indifferent_access
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports missing fields" do
       blacklight_config.index.display_type_field = :type
-      doc = {}
+      doc = {}.with_indifferent_access
       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" }.with_indifferent_access
       expect(helper.render_document_class(doc)).to eq "blacklight-document"
     end
   end
@@ -338,11 +233,11 @@ RSpec.describe CatalogHelper do
     end
 
     it "is bookmarked if the document is in the bookmarks" do
-      expect(helper.bookmarked?(bookmarked_document)).to eq true
+      expect(helper.bookmarked?(bookmarked_document)).to be true
     end
 
     it "does not be bookmarked if the document is not listed in the bookmarks" do
-      expect(helper.bookmarked?(SolrDocument.new(id: 'b'))).to eq false
+      expect(helper.bookmarked?(SolrDocument.new(id: 'b'))).to be false
     end
   end
 
@@ -388,11 +283,5 @@ RSpec.describe CatalogHelper do
 
       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