blacklight 7.33.0 → 8.0.0

data/spec/lib/blacklight/open_struct_with_hash_access_spec.rb

@@ -54,11 +54,11 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
     end
 
     it "is true if the key exists" do
-      expect(subject.key?(:a)).to eq true
+      expect(subject.key?(:a)).to be true
     end
 
     it "is false if the key does not exist" do
-      expect(subject.key?(:c)).to eq false
+      expect(subject.key?(:c)).to be false
     end
   end
 
@@ -76,7 +76,7 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
 
     it "sorts the underlying hash" do
       sorted = subject.sort_by { |_k, v| v }
-      expect(sorted.keys).to match_array [:b, :a, :c]
+      expect(sorted.keys).to contain_exactly(:b, :a, :c)
     end
   end
 
@@ -85,7 +85,7 @@ RSpec.describe Blacklight::OpenStructWithHashAccess do
 
     it "sorts the underlying hash" do
       subject.sort_by! { |_k, v| v }
-      expect(subject.keys).to match_array [:b, :a, :c]
+      expect(subject.keys).to contain_exactly(:b, :a, :c)
     end
   end
 

data/spec/lib/blacklight/parameters_spec.rb

@@ -72,11 +72,8 @@ RSpec.describe Blacklight::Parameters do
     context 'with filter_search_state_fields set to false' do
       let(:blacklight_config) { Blacklight::Configuration.new(filter_search_state_fields: false) }
 
-      it 'allows all params, but warns about the behavior' do
-        allow(Deprecation).to receive(:warn)
+      it 'allows all params' do
         expect(params.permit_search_params.to_h.with_indifferent_access).to include(a: 1, b: 2, c: [])
-
-        expect(Deprecation).to have_received(:warn).with(described_class, /including: a, b, and c/).at_least(:once)
       end
     end
 

data/spec/lib/blacklight/search_state/filter_field_spec.rb

@@ -160,7 +160,7 @@ RSpec.describe Blacklight::SearchState::FilterField do
 
     context "With facet.missing field" do
       let(:params) do
-        { f: { "-some_field": ["[* TO *]"] } }
+        { f: { '-some_field': ["[* TO *]"] } }
       end
 
       it "removes facet.missing facet params" do
@@ -190,12 +190,12 @@ RSpec.describe Blacklight::SearchState::FilterField do
 
   describe '#include?' do
     it 'checks whether the value is currently selected' do
-      expect(search_state.filter('some_field').include?('1')).to eq true
-      expect(search_state.filter('some_field').include?('3')).to eq false
+      expect(search_state.filter('some_field').include?('1')).to be true
+      expect(search_state.filter('some_field').include?('3')).to be false
     end
 
     it 'handles value indirection' do
-      expect(search_state.filter('some_field').include?(OpenStruct.new(value: '1'))).to eq true
+      expect(search_state.filter('some_field').include?(OpenStruct.new(value: '1'))).to be true
     end
   end
 end

data/spec/lib/blacklight/search_state/pivot_filter_field_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::SearchState::PivotFilterField do
+  let(:value_class) { described_class::PivotValue }
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config, controller) }
+
+  let(:params) { { f: { some_field: %w[1 2], some_other_field: ['3'] } } }
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_facet_field 'pivot_field', pivot: %w[some_field some_other_field], filter_class: described_class
+    end
+  end
+  let(:controller) { double }
+
+  describe '#add' do
+    context 'with a string value' do
+      it 'adds the parameter to the first pivot\'s filter list' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.add('4')
+
+        expect(new_state.filter('some_field').values).to eq %w[1 2 4]
+        expect(new_state.filter('pivot_field').values&.map(&:value)).to eq %w[1 2 4]
+      end
+
+      context 'without any parameters in the url' do
+        let(:params) { {} }
+
+        it 'adds the necessary structure' do
+          filter = search_state.filter('some_field')
+          new_state = filter.add('1')
+
+          expect(new_state.filter('pivot_field').values&.map(&:value)).to eq %w[1]
+          expect(new_state.params).to include(:f)
+        end
+      end
+    end
+
+    context 'with a pivot facet-type item' do
+      it 'includes the pivot facet fqs' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.add(value_class.new(fq: { some_other_field: '5' }, value: '4'))
+
+        expect(new_state.filter('some_field').values).to eq %w[1 2 4]
+        expect(new_state.filter('some_other_field').values).to eq %w[3 5]
+      end
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+  end
+
+  describe '#remove' do
+    it 'returns a search state without the given filter applied' do
+      filter = search_state.filter('some_field')
+      new_state = filter.remove('1')
+
+      expect(new_state.filter('pivot_field').values&.map(&:value)).to eq ['2']
+    end
+
+    context 'with a pivot facet-type item' do
+      it 'includes the pivot facet fqs' do
+        filter = search_state.filter('pivot_field')
+        new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+
+        expect(new_state.filter('some_field').values).to eq %w[2]
+        expect(new_state.filter('some_other_field').values).to eq []
+      end
+    end
+
+    it 'removes the whole field if there are no filter left for the field' do
+      filter = search_state.filter('pivot_field')
+      new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+
+      expect(new_state.params[:f]).not_to include :some_other_field
+      expect(new_state.filter('pivot_field').values&.map(&:fq)).to eql([some_other_field: nil])
+    end
+
+    it 'removes the filter parameter entirely if there are no filters left' do
+      filter = search_state.filter('pivot_field')
+      new_state = filter.remove(value_class.new(fq: { some_other_field: '3' }, value: '1'))
+      new_state = new_state.filter('pivot_field').remove(value_class.new(fq: { some_other_field: '3' }, value: '2'))
+
+      expect(new_state.filter('pivot_field').values).to eq []
+      expect(new_state.params).not_to include :f
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+
+    context "With facet.missing field" do
+      pending 'decide how facet.missing should work with pivots'
+    end
+  end
+
+  describe '#values' do
+    it 'returns the currently selected values of the filter' do
+      expect(search_state.filter('pivot_field').values.map(&:value)).to eq %w[1 2]
+    end
+
+    context 'with an array' do
+      pending 'decide how inclusive facets should work with pivots'
+    end
+  end
+
+  describe '#include?' do
+    it 'checks whether the value is currently selected' do
+      expect(search_state.filter('some_field').include?('1')).to be true
+      expect(search_state.filter('some_field').include?('3')).to be false
+    end
+
+    it 'handles value indirection' do
+      expect(search_state.filter('some_field').include?(value_class.new(value: '1'))).to be true
+    end
+  end
+end

data/spec/lib/blacklight/search_state_spec.rb

@@ -3,8 +3,6 @@
 RSpec.describe Blacklight::SearchState do
   subject(:search_state) { described_class.new(params, blacklight_config, controller) }
 
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
       config.index.title_field = 'title_tsim'
@@ -81,19 +79,6 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe 'interface compatibility with params' do
-    let(:simple_facet_fields) { [:ff] }
-    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
-
-    it 'implements param methods' do
-      Deprecation.silence(described_class) do
-        expect(search_state.to_unsafe_h).to eq('f' => { 'ff' => ['xyz'] })
-        expect(search_state.fetch(:f)).to eq('ff' => ['xyz'])
-        expect(search_state.select { |k, _v,| k == 'f' }).to eq('f' => { 'ff' => ['xyz'] })
-      end
-    end
-  end
-
   describe '#query_param' do
     let(:params) { parameter_class.new q: 'xyz' }
 
@@ -102,25 +87,16 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe '#filter_params' do
-    let(:simple_facet_fields) { [:ff] }
-    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
-
-    it 'returns the query param' do
-      expect(search_state.filter_params.deep_symbolize_keys).to eq(ff: ['xyz'])
-    end
-  end
-
   describe '#has_constraints?' do
     it 'is false' do
-      expect(search_state.has_constraints?).to eq false
+      expect(search_state.has_constraints?).to be false
     end
 
     context 'with a query param' do
       let(:params) { parameter_class.new q: 'xyz' }
 
       it 'is true' do
-        expect(search_state.has_constraints?).to eq true
+        expect(search_state.has_constraints?).to be true
       end
     end
 
@@ -129,7 +105,7 @@ RSpec.describe Blacklight::SearchState do
       let(:params) { parameter_class.new f: { ff: ['xyz'] } }
 
       it 'is true' do
-        expect(search_state.has_constraints?).to eq true
+        expect(search_state.has_constraints?).to be true
       end
     end
   end
@@ -213,112 +189,6 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
-  describe "add_facet_params" do
-    let(:params_no_existing_facet) do
-      parameter_class.new q: "query",
-                          search_field: "search_field",
-                          per_page: "50"
-    end
-    let(:params_existing_facets) do
-      parameter_class.new q: "query",
-                          search_field: "search_field",
-                          per_page: "50",
-                          f: { "facet_field_1" => ["value1"],
-                               "facet_field_2" => %w[value2 value2a] }
-    end
-
-    context "when there are no pre-existing facets" do
-      let(:params) { params_no_existing_facet }
-
-      it "adds facet value" do
-        result_params = search_state.add_facet_params("facet_field", "facet_value")
-        expect(result_params[:f]).to be_a Hash
-        expect(result_params[:f]["facet_field"]).to be_a_kind_of(Array)
-        expect(result_params[:f]["facet_field"]).to eq ["facet_value"]
-      end
-
-      it "leaves non-facet params alone" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        params.each_pair do |key, _value|
-          next if key == :f
-
-          expect(result_params[key]).to eq params[key]
-        end
-      end
-
-      it "uses the facet's key in the url" do
-        blacklight_config.add_facet_field 'some_key', single: true, field: "a_solr_field"
-
-        result_params = search_state.add_facet_params('some_key', 'my_value')
-
-        expect(result_params[:f]['some_key']).to have(1).item
-        expect(result_params[:f]['some_key'].first).to eq 'my_value'
-      end
-    end
-
-    context "when there are pre-existing facets" do
-      let(:params) { params_existing_facets }
-
-      it "adds a facet param to existing facet constraints" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        expect(result_params[:f]).to be_a Hash
-
-        params_existing_facets[:f].each_pair do |facet_field, _value_list|
-          expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
-          if facet_field == 'facet_field_2'
-            expect(result_params[:f][facet_field]).to eq (params_existing_facets[:f][facet_field] | ["new_facet_value"])
-          else
-            expect(result_params[:f][facet_field]).to eq params_existing_facets[:f][facet_field]
-          end
-        end
-      end
-
-      it "leaves non-facet params alone" do
-        result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
-
-        params.each_pair do |key, _value|
-          next if key == 'f'
-
-          expect(result_params[key]).to eq params[key]
-        end
-      end
-    end
-
-    context "with a facet selected in the params" do
-      let(:params) { parameter_class.new f: { 'single_value_facet_field' => 'other_value' } }
-
-      it "replaces facets configured as single" do
-        blacklight_config.add_facet_field 'single_value_facet_field', single: true
-        result_params = search_state.add_facet_params('single_value_facet_field', 'my_value')
-
-        expect(result_params[:f]['single_value_facet_field']).to have(1).item
-        expect(result_params[:f]['single_value_facet_field'].first).to eq 'my_value'
-      end
-    end
-
-    it "accepts a FacetItem instead of a plain facet value" do
-      result_params = search_state.add_facet_params('facet_field_1', double(value: 123))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-    end
-
-    it "defers to the field set on a FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(field: 'facet_field_2', value: 123))
-
-      expect(result_params[:f]['facet_field_1']).to be_blank
-      expect(result_params[:f]['facet_field_2']).to include(123)
-    end
-
-    it "adds any extra fq parameters from the FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(value: 123, fq: { 'facet_field_2' => 'abc' }))
-
-      expect(result_params[:f]['facet_field_1']).to include(123)
-      expect(result_params[:f]['facet_field_2']).to include('abc')
-    end
-  end
-
   describe "add_facet_params_and_redirect" do
     let(:params) do
       parameter_class.new(
@@ -346,71 +216,6 @@ RSpec.describe Blacklight::SearchState do
       params = search_state.add_facet_params_and_redirect("facet_field_2", "facet_value")
       expect(params).not_to have_key(:page)
     end
-
-    it "otherwise does the same thing as add_facet_params" do
-      added_facet_params = search_state.add_facet_params("facet_field_2", "facet_value")
-      added_facet_params_from_facet_action = search_state.add_facet_params_and_redirect("facet_field_2", "facet_value")
-
-      expect(added_facet_params_from_facet_action).to eq added_facet_params.except(Blacklight::Solr::FacetPaginator.request_keys[:page], Blacklight::Solr::FacetPaginator.request_keys[:sort])
-    end
-  end
-
-  describe "#remove_facet_params" do
-    let(:simple_facet_fields) { [:some_field, :another_field] }
-    let(:params) { parameter_class.new 'f' => facet_params }
-    let(:facet_params) { {} }
-
-    context "when the facet has multiple values" do
-      let(:facet_params) { { 'some_field' => %w[some_value another_value] } }
-
-      it "removes the facet / value tuple from the query parameters" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_field']).not_to include 'some_value'
-        expect(params[:f]['some_field']).to include 'another_value'
-      end
-    end
-
-    context "when the facet_params is a HWIA" do
-      let(:facet_values) { { '0' => 'some_value', '1' => 'another_value' }.with_indifferent_access }
-      let(:facet_params) { { 'some_field' => facet_values } }
-
-      it "removes the facet / value tuple from the query parameters" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_field']).not_to include 'some_value'
-        expect(params[:f]['some_field']).to include 'another_value'
-      end
-    end
-
-    context "when the facet has configuration" do
-      before do
-        blacklight_config.facet_fields['some_field'].merge!(single: true, field: "a_solr_field", key: 'some_key')
-      end
-
-      let(:facet_params) { { 'some_key' => %w[some_value another_value] } }
-
-      it "uses the facet's key configuration" do
-        params = search_state.remove_facet_params('some_field', 'some_value')
-        expect(params[:f]['some_key']).not_to eq 'some_value'
-        expect(params[:f]['some_key']).to include 'another_value'
-      end
-    end
-
-    it "removes the facet entirely when the last facet value is removed" do
-      facet_params['another_field'] = ['some_value']
-      facet_params['some_field'] = ['some_value']
-
-      params = search_state.remove_facet_params('some_field', 'some_value')
-
-      expect(params[:f]).not_to have_key 'some_field'
-    end
-
-    it "removes the 'f' parameter entirely when no facets remain" do
-      facet_params['some_field'] = ['some_value']
-
-      params = search_state.remove_facet_params('some_field', 'some_value')
-
-      expect(params).not_to have_key :f
-    end
   end
 
   describe '#reset' do
@@ -549,4 +354,81 @@ RSpec.describe Blacklight::SearchState do
       expect(search_state.facet_prefix).to eq 'A'
     end
   end
+
+  describe "#url_for_document" do
+    let(:controller_class) { ::CatalogController.new }
+    let(:doc) { SolrDocument.new }
+
+    before do
+      allow(search_state).to receive_messages(controller: controller_class)
+      allow(search_state).to receive_messages(controller_name: controller_class.controller_name)
+      allow(search_state).to receive_messages(params: parameter_class.new)
+    end
+
+    it "is a polymorphic routing-ready object" do
+      expect(search_state.url_for_document(doc)).to eq doc
+    end
+
+    it "allows for custom show routes" do
+      search_state.blacklight_config.show.route = { controller: 'catalog' }
+      expect(search_state.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(search_state.url_for_document(doc)).to eq doc
+      end
+    end
+
+    context "within an alternative catalog controller" do
+      let(:controller_class) { ::AlternateController.new }
+
+      before do
+        search_state.blacklight_config.show.route = { controller: :current }
+        allow(search_state).to receive(:params).and_return(parameter_class.new(controller: 'alternate'))
+      end
+
+      it "supports the :current controller configuration" do
+        expect(search_state.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(search_state.url_for_document(doc)).to eq doc
+    end
+  end
+
+  describe '#filters' do
+    context 'pivot facet config but no facet params' do
+      it 'maps no filters' do
+        blacklight_config.add_facet_field 'some_key', pivot: %w[pivot_field_1 pivot_field_2]
+        expect(search_state.filters).to eq([])
+      end
+    end
+
+    context 'pivot facet config and some pivot facet params' do
+      let(:params) { { 'f' => { 'pivot_field_1' => 'foo' } } }
+
+      it 'maps the pivot matching param pivot_field' do
+        blacklight_config.add_facet_field 'some_key', pivot: %w[pivot_field_1 pivot_field_2]
+        expect(search_state.filters.count).to eq(1)
+        expect(search_state.filters.first.key).to eq('some_key')
+      end
+    end
+
+    context 'regular facet config with params' do
+      let(:params) { { 'f' => { 'some_key' => 'foo' } } }
+
+      it 'maps the field matching param facet_field' do
+        blacklight_config.add_facet_field 'some_key'
+        expect(search_state.filters.count).to eq(1)
+        expect(search_state.filters.first.key).to eq('some_key')
+      end
+    end
+  end
 end

data/spec/lib/tasks/blacklight_task_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'rake'
 
 RSpec.describe "blacklight:delete_old_searches" do

data/spec/models/blacklight/configuration_spec.rb

@@ -39,13 +39,13 @@ RSpec.describe "Blacklight::Configuration", api: true do
     end
 
     it "has ordered hashes for field configuration" do
-      expect(config.facet_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.index_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.show_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.search_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.show_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.search_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
-      expect(config.sort_fields).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
+      expect(config.facet_fields).to be_a_kind_of Hash
+      expect(config.index_fields).to be_a_kind_of Hash
+      expect(config.show_fields).to be_a_kind_of Hash
+      expect(config.search_fields).to be_a_kind_of Hash
+      expect(config.show_fields).to be_a_kind_of Hash
+      expect(config.search_fields).to be_a_kind_of Hash
+      expect(config.sort_fields).to be_a_kind_of Hash
     end
   end
 
@@ -96,28 +96,6 @@ RSpec.describe "Blacklight::Configuration", api: true do
     let(:image) { SolrDocument.new(format: 'Image') }
     let(:sound) { SolrDocument.new(format: 'Sound') }
 
-    context 'with deprecated behavior' do
-      before do
-        allow(Deprecation).to receive(:warn)
-      end
-
-      it 'accepts documents as an argument to index_fields_for' do
-        config.for_display_type "Image" do |c|
-          c.add_index_field :dimensions
-        end
-        config.add_index_field :title
-        expect(config.index_fields_for(image)).to have_key 'dimensions'
-      end
-
-      it 'accepts documents as an argument to show_fields_for' do
-        config.for_display_type "Image" do |c|
-          c.add_show_field :dimensions
-        end
-        config.add_show_field :title
-        expect(config.show_fields_for(image)).to have_key 'dimensions'
-      end
-    end
-
     it "adds index fields just for a certain type" do
       config.for_display_type "Image" do |c|
         c.add_index_field :dimensions
@@ -183,18 +161,6 @@ RSpec.describe "Blacklight::Configuration", api: true do
       end
     end
 
-    context "when model classes are not set" do
-      it "leaves response_model and document_model empty" do
-        expect(config_copy.fetch(:response_model, nil)).to be_nil
-        expect(config_copy.fetch(:document_model, nil)).to be_nil
-      end
-
-      it "returns default classes" do
-        expect(config_copy.response_model).to eq Blacklight::Solr::Response
-        expect(config_copy.document_model).to eq SolrDocument
-      end
-    end
-
     it "provides cloned copies of mutable data structures" do
       config.a = { value: 1 }
       config.b = [1, 2, 3]
@@ -206,8 +172,8 @@ RSpec.describe "Blacklight::Configuration", api: true do
 
       expect(config.a[:value]).to eq 1
       expect(config_copy.a[:value]).to eq 2
-      expect(config.b).to match_array [1, 2, 3]
-      expect(config_copy.b).to match_array [1, 2, 3, 5]
+      expect(config.b).to contain_exactly(1, 2, 3)
+      expect(config_copy.b).to contain_exactly(1, 2, 3, 5)
       expect(config.c.value).to match_array %w[a b]
       expect(config_copy.c.value).to match_array %w[a b c]
     end
@@ -327,17 +293,17 @@ RSpec.describe "Blacklight::Configuration", api: true do
 
     describe "if/unless conditions with legacy show parameter" do
       it "is hidden if the if condition is false" do
-        expect(config.add_facet_field("hidden", if: false).if).to eq false
-        expect(config.add_facet_field("hidden_with_legacy", if: false, show: true).if).to eq false
+        expect(config.add_facet_field("hidden", if: false).if).to be false
+        expect(config.add_facet_field("hidden_with_legacy", if: false, show: true).if).to be false
       end
 
       it "is true if the if condition is true" do
-        expect(config.add_facet_field("hidden", if: true).if).to eq true
-        expect(config.add_facet_field("hidden_with_legacy", if: true, show: false).if).to eq true
+        expect(config.add_facet_field("hidden", if: true).if).to be true
+        expect(config.add_facet_field("hidden_with_legacy", if: true, show: false).if).to be true
       end
 
       it "is true if the if condition is missing" do
-        expect(config.add_facet_field("hidden", show: true).if).to eq true
+        expect(config.add_facet_field("hidden", show: true).if).to be true
       end
     end
   end
@@ -498,17 +464,17 @@ RSpec.describe "Blacklight::Configuration", api: true do
 
     describe "if/unless conditions with legacy include_in_simple_search" do
       it "is hidden if the if condition is false" do
-        expect(config.add_search_field("hidden", if: false).if).to eq false
-        expect(config.add_search_field("hidden_with_legacy", if: false, include_in_simple_search: true).if).to eq false
+        expect(config.add_search_field("hidden", if: false).if).to be false
+        expect(config.add_search_field("hidden_with_legacy", if: false, include_in_simple_search: true).if).to be false
       end
 
       it "is true if the if condition is true" do
-        expect(config.add_search_field("hidden", if: true).if).to eq true
-        expect(config.add_search_field("hidden_with_legacy", if: true, include_in_simple_search: false).if).to eq true
+        expect(config.add_search_field("hidden", if: true).if).to be true
+        expect(config.add_search_field("hidden_with_legacy", if: true, include_in_simple_search: false).if).to be true
       end
 
       it "is true if the if condition is missing" do
-        expect(config.add_search_field("hidden", include_in_simple_search: true).if).to eq true
+        expect(config.add_search_field("hidden", include_in_simple_search: true).if).to be true
       end
     end
   end
@@ -723,4 +689,26 @@ RSpec.describe "Blacklight::Configuration", api: true do
       expect { config.view.a = '123' }.to raise_error(FrozenError)
     end
   end
+
+  describe '.default_configuration' do
+    it 'adds additional default configuration properties' do
+      Blacklight::Configuration.default_configuration do
+        Blacklight::Configuration.default_values[:a] = '123'
+      end
+
+      Blacklight::Configuration.default_configuration do
+        Blacklight::Configuration.default_values[:b] = 'abc'
+      end
+
+      expect(Blacklight::Configuration.default_values[:a]).to eq '123'
+      expect(Blacklight::Configuration.default_values[:b]).to eq 'abc'
+    ensure
+      # reset the default configuration
+      Blacklight::Configuration.default_values.delete(:a)
+      Blacklight::Configuration.default_values.delete(:b)
+
+      Blacklight::Configuration.default_configuration.delete_at(1)
+      Blacklight::Configuration.default_configuration.delete_at(2)
+    end
+  end
 end