blacklight 7.33.0 → 8.0.0

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,153 +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
-    it "checks if the response ivar contains grouped data" do
-      assign(:response, instance_double(Blacklight::Solr::Response, grouped?: true))
-      expect(helper.render_grouped_response?).to be true
-    end
-
-    it "checks if the response param contains grouped data" do
-      response = instance_double(Blacklight::Solr::Response, grouped?: true)
-      expect(helper.render_grouped_response?(response)).to be true
-    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
@@ -344,153 +198,4 @@ RSpec.describe BlacklightHelper do
       end
     end
   end
-
-  describe "#document_index_view_type" do
-    it "defaults to the default view" do
-      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
-      allow(helper).to receive(:default_document_index_view_type).and_return(:xyz)
-      expect(helper.document_index_view_type).to eq :xyz
-    end
-
-    it "uses the query parameter" do
-      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
-      expect(helper.document_index_view_type(view: :a)).to eq :a
-    end
-
-    it "uses the default view if the requested view is not available" do
-      allow(helper).to receive(:default_document_index_view_type).and_return(:xyz)
-      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
-      expect(helper.document_index_view_type(view: :c)).to eq :xyz
-    end
-
-    context "when they have a preferred view" do
-      before do
-        session[:preferred_view] = :b
-      end
-
-      context "and no view is specified" do
-        it "uses the saved preference" do
-          allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2, c: 3)
-          expect(helper.document_index_view_type).to eq :b
-        end
-
-        it "uses the default view if the preference is not available" do
-          allow(helper).to receive(:document_index_views).and_return(a: 1)
-          expect(helper.document_index_view_type).to eq :a
-        end
-      end
-
-      context "and a view is specified" do
-        it "uses the query parameter" do
-          allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2, c: 3)
-          expect(helper.document_index_view_type(view: :c)).to eq :c
-        end
-      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,61 @@ RSpec.describe CatalogHelper do
 
       it { is_expected.to eq "foobar / Format: Book" }
     end
+  end
 
-    context 'when the f param is not an array' do
-      let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: 'Book' }) }
+  describe "render_grouped_response?" do
+    it "checks if the response ivar contains grouped data" do
+      assign(:response, instance_double(Blacklight::Solr::Response, grouped?: true))
+      expect(helper.render_grouped_response?).to be true
+    end
 
-      it { is_expected.to eq "foobar / Format: Book" }
+    it "checks if the response param contains grouped data" do
+      response = instance_double(Blacklight::Solr::Response, grouped?: true)
+      expect(helper.render_grouped_response?(response)).to be true
+    end
+  end
+
+  describe "#document_index_view_type" do
+    it "defaults to the default view" do
+      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
+      allow(helper).to receive(:default_document_index_view_type).and_return(:xyz)
+      expect(helper.document_index_view_type).to eq :xyz
+    end
+
+    it "uses the query parameter" do
+      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
+      expect(helper.document_index_view_type(view: :a)).to eq :a
+    end
+
+    it "uses the default view if the requested view is not available" do
+      allow(helper).to receive(:default_document_index_view_type).and_return(:xyz)
+      allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2)
+      expect(helper.document_index_view_type(view: :c)).to eq :xyz
+    end
+
+    context "when they have a preferred view" do
+      before do
+        session[:preferred_view] = :b
+      end
+
+      context "and no view is specified" do
+        it "uses the saved preference" do
+          allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2, c: 3)
+          expect(helper.document_index_view_type).to eq :b
+        end
+
+        it "uses the default view if the preference is not available" do
+          allow(helper).to receive(:document_index_views).and_return(a: 1)
+          expect(helper.document_index_view_type).to eq :a
+        end
+      end
+
+      context "and a view is specified" do
+        it "uses the query parameter" do
+          allow(helper).to receive(:document_index_views).and_return(a: 1, b: 2, c: 3)
+          expect(helper.document_index_view_type(view: :c)).to eq :c
+        end
+      end
     end
   end
 end

data/spec/i18n_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'i18n/tasks'
 
 RSpec.describe 'I18n', type: :i18n do

data/spec/integration/generators/blacklight/solr_generator_spec.rb

@@ -20,7 +20,7 @@ RSpec.describe Blacklight::SolrGenerator do
     end
 
     after do
-      files_to_test.each { |file| File.delete(file) if File.exist?(file) }
+      files_to_test.each { |file| FileUtils.rm_rf(file) }
     end
 
     it "creates config files" do

data/spec/lib/blacklight/configuration/facet_field_spec.rb

@@ -1,30 +1,41 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::Configuration::FacetField do
-  describe 'link_to_search' do
-    subject { described_class.new(link_to_search: true) }
-
-    it 'is deprecated' do
-      expect(Deprecation).to receive(:warn)
-      expect(subject.normalize!)
-      expect(subject.link_to_facet).to eq true
-    end
-  end
-
   describe '#normalize!' do
-    it 'preserves existing properties' do
-      expected = double
-      subject.presenter = expected
+    context 'with existing properties' do
+      let(:expected_presenter) { double }
+      let(:expected_component) { double }
 
-      subject.normalize!
+      before do
+        subject.presenter = expected_presenter
+        subject.component = expected_component
+      end
 
-      expect(subject.presenter).to eq expected
+      it 'preserves existing properties' do
+        subject.normalize!
+
+        expect(subject.presenter).to eq expected_presenter
+        expect(subject.component).to eq expected_component
+      end
     end
 
-    it 'adds a default presenter' do
+    it 'adds a default presenter and component' do
       subject.normalize!
 
       expect(subject.presenter).to eq Blacklight::FacetFieldPresenter
+      expect(subject.component).to eq Blacklight::FacetFieldListComponent
+    end
+
+    context 'when component is set to true' do
+      before do
+        subject.component = true
+      end
+
+      it 'casts to the default component' do
+        subject.normalize!
+
+        expect(subject.component).to eq Blacklight::FacetFieldListComponent
+      end
     end
   end
 end

data/spec/lib/blacklight/configuration/field_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Blacklight::Configuration::Field do
 
   describe '#display_label' do
     it "looks up the label to display for the given document and field" do
-      allow(I18n).to receive(:t).with(:"blacklight.search.fields.my_context.some_key", default: [:"blacklight.search.fields.some_key", label, subject.default_label]).and_return('x')
+      allow(I18n).to receive(:t).with(:'blacklight.search.fields.my_context.some_key', default: [:'blacklight.search.fields.some_key', label, subject.default_label]).and_return('x')
       expect(subject.display_label('my_context')).to eq 'x'
     end
   end

data/spec/lib/blacklight/configuration/session_tracking_config_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Configuration::SessionTrackingConfig do
+  subject(:config) { described_class.new }
+
+  it "defaults @storage to 'server'" do
+    expect(config.storage).to eq 'server'
+  end
+
+  context "@storage is set to 'server'" do
+    before do
+      config.storage = 'server'
+    end
+
+    it "defaults components values" do
+      expect(config.applied_params_component).to eq Blacklight::SearchContext::ServerAppliedParamsComponent
+      expect(config.item_pagination_component).to eq Blacklight::SearchContext::ServerItemPaginationComponent
+    end
+
+    it "defaults tracking url helper" do
+      expect(config.url_helper).to be_nil
+    end
+  end
+
+  context "@storage is set to false" do
+    before do
+      config.storage = false
+    end
+
+    it "defaults components values" do
+      expect(config.applied_params_component).to be_nil
+    end
+
+    it "defaults tracking url helper" do
+      expect(config.url_helper).to be_nil
+    end
+  end
+end

data/spec/lib/blacklight/configuration/view_config_spec.rb

@@ -8,7 +8,7 @@ RSpec.describe Blacklight::Configuration::ViewConfig do
 
   describe '#display_label' do
     it "looks up the label to display for the given document and field" do
-      allow(I18n).to receive(:t).with(:"blacklight.search.view_title.my_view", default: [:"blacklight.search.view.my_view", label, nil, "My view"]).and_return('x')
+      allow(I18n).to receive(:t).with(:'blacklight.search.view_title.my_view', default: [:'blacklight.search.view.my_view', label, nil, "My view"]).and_return('x')
       expect(subject.display_label).to eq 'x'
     end
   end