blacklight 9.0.0.beta1 → 9.0.0

data/spec/models/blacklight/solr/response/facets_spec.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::Solr::Response::Facets, :api do
+  let(:search_builder) do
+    Blacklight::SearchBuilder.new(view_context)
+  end
+  let(:view_context) do
+    double("View context", blacklight_config: CatalogController.blacklight_config.deep_copy)
+  end
+
   describe Blacklight::Solr::Response::Facets::FacetField do
     describe "A field with default options" do
       subject(:field) { described_class.new "my_field", [] }
@@ -60,22 +67,29 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   describe "#aggregations" do
-    subject { Blacklight::Solr::Response.new({ responseHeader: response_header, facet_counts: { facet_fields: [facet_field] } }, request_params) }
+    subject { Blacklight::Solr::Response.new({ responseHeader: {}, facet_counts: { facet_fields: [facet_field] } }, search_builder) }
 
     let(:facet_field) { ['my_field', []] }
-    let(:response_header) { { params: request_params } }
-    let(:request_params) { {} }
 
     describe "#limit" do
-      it "extracts a field-specific limit value" do
-        request_params['f.my_field.facet.limit'] = "10"
-        request_params['facet.limit'] = "15"
-        expect(subject.aggregations['my_field'].limit).to eq 10
+      context 'with a field-specific limit value' do
+        before do
+          search_builder.merge('f.my_field.facet.limit' => '10', 'facet.limit' => '15')
+        end
+
+        it "extracts a field-specific limit value" do
+          expect(subject.aggregations['my_field'].limit).to eq 10
+        end
       end
 
-      it "extracts a global limit value" do
-        request_params['facet.limit'] = "15"
-        expect(subject.aggregations['my_field'].limit).to eq 15
+      context 'with a global limit value' do
+        before do
+          search_builder.merge('facet.limit' => '15')
+        end
+
+        it "extracts a global limit value" do
+          expect(subject.aggregations['my_field'].limit).to eq 15
+        end
       end
 
       it "is the solr default limit if no value is found" do
@@ -84,15 +98,24 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
     end
 
     describe "#offset" do
-      it "extracts a field-specific offset value" do
-        request_params['f.my_field.facet.offset'] = "10"
-        request_params['facet.offset'] = "15"
-        expect(subject.aggregations['my_field'].offset).to eq 10
+      context 'with a field-specific offset value' do
+        before do
+          search_builder.merge('f.my_field.facet.offset' => '10', 'facet.offset' => '15')
+        end
+
+        it "extracts a field-specific offset value" do
+          expect(subject.aggregations['my_field'].offset).to eq 10
+        end
       end
 
-      it "extracts a global offset value" do
-        request_params['facet.offset'] = "15"
-        expect(subject.aggregations['my_field'].offset).to eq 15
+      context 'with a global offset value' do
+        before do
+          search_builder.merge('facet.offset' => '15')
+        end
+
+        it "extracts a global offset value" do
+          expect(subject.aggregations['my_field'].offset).to eq 15
+        end
       end
 
       it "is nil if no value is found" do
@@ -101,15 +124,24 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
     end
 
     describe "#sort" do
-      it "extracts a field-specific sort value" do
-        request_params['f.my_field.facet.sort'] = "alpha"
-        request_params['facet.sort'] = "index"
-        expect(subject.aggregations['my_field'].sort).to eq 'alpha'
+      context 'with a field-specific sort value' do
+        before do
+          search_builder.merge('f.my_field.facet.sort' => 'alpha', 'facet.sort' => 'index')
+        end
+
+        it "extracts a field-specific sort value" do
+          expect(subject.aggregations['my_field'].sort).to eq 'alpha'
+        end
       end
 
-      it "extracts a global sort value" do
-        request_params['facet.sort'] = "alpha"
-        expect(subject.aggregations['my_field'].sort).to eq 'alpha'
+      context 'with a global sort value' do
+        before do
+          search_builder.merge('facet.sort' => 'alpha')
+        end
+
+        it "extracts a global sort value" do
+          expect(subject.aggregations['my_field'].sort).to eq 'alpha'
+        end
       end
 
       it "defaults to count if no value is found and the default limit is used" do
@@ -117,23 +149,37 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
         expect(subject.aggregations['my_field'].count?).to be true
       end
 
-      it "defaults to index if no value is found and the limit is unlimited" do
-        request_params['facet.limit'] = -1
-        expect(subject.aggregations['my_field'].sort).to eq 'index'
-        expect(subject.aggregations['my_field'].index?).to be true
+      context 'when no value is found and the limit is unlimited' do
+        before do
+          search_builder.merge('facet.limit' => -1)
+        end
+
+        it "defaults to index" do
+          expect(subject.aggregations['my_field'].sort).to eq 'index'
+          expect(subject.aggregations['my_field'].index?).to be true
+        end
       end
     end
 
     describe '#prefix' do
-      it 'extracts field-specific prefix values' do
-        request_params['f.my_field.facet.prefix'] = "a"
-        request_params['facet.prefix'] = "b"
-        expect(subject.aggregations['my_field'].prefix).to eq 'a'
+      context 'with a field-specific prefix value' do
+        before do
+          search_builder.merge('f.my_field.facet.prefix' => 'a', 'facet.prefix' => 'b')
+        end
+
+        it "extracts a field-specific prefix value" do
+          expect(subject.aggregations['my_field'].prefix).to eq 'a'
+        end
       end
 
-      it "extracts a global sort value" do
-        request_params['facet.prefix'] = "abc"
-        expect(subject.aggregations['my_field'].prefix).to eq 'abc'
+      context 'with a global prefix value' do
+        before do
+          search_builder.merge('facet.prefix' => 'abc')
+        end
+
+        it "extracts a global prefix value" do
+          expect(subject.aggregations['my_field'].prefix).to eq 'abc'
+        end
       end
 
       it "defaults to no prefix value" do
@@ -149,7 +195,7 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   describe "#merge_facet" do
-    let(:response) { Blacklight::Solr::Response.new(facet_counts, {}, {}) }
+    let(:response) { Blacklight::Solr::Response.new(facet_counts, search_builder, {}) }
     let(:facet) { { name: "foo", value: "bar", hits: 1 } }
 
     before do
@@ -186,7 +232,7 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   context "facet.missing" do
-    subject { Blacklight::Solr::Response.new(response, {}) }
+    subject { Blacklight::Solr::Response.new(response, search_builder) }
 
     let(:response) do
       {
@@ -213,7 +259,7 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   describe "query facets" do
-    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+    subject { Blacklight::Solr::Response.new(response, search_builder, blacklight_config: blacklight_config) }
 
     let(:facet_config) do
       double(
@@ -288,7 +334,7 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   describe "pivot facets" do
-    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+    subject { Blacklight::Solr::Response.new(response, search_builder, blacklight_config: blacklight_config) }
 
     let(:facet_config) do
       double(key: 'my_pivot_facet_field', query: nil, pivot: %w[field_a field_b])
@@ -330,7 +376,7 @@ RSpec.describe Blacklight::Solr::Response::Facets, :api do
   end
 
   describe 'json facets' do
-    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+    subject { Blacklight::Solr::Response.new(response, search_builder, blacklight_config: blacklight_config) }
 
     let(:response) do
       {

data/spec/models/blacklight/solr/response/group_response_spec.rb

@@ -4,7 +4,14 @@ require "spec_helper"
 
 RSpec.describe Blacklight::Solr::Response::GroupResponse, :api do
   let(:response) do
-    create_response(sample_response)
+    Blacklight::Solr::Response.new(sample_response, search_builder)
+  end
+
+  let(:search_builder) do
+    Blacklight::SearchBuilder.new(view_context).tap { |b| b.rows = 3 }
+  end
+  let(:view_context) do
+    double("View context", blacklight_config: CatalogController.blacklight_config.deep_copy)
   end
 
   let(:group) do
@@ -82,10 +89,6 @@ RSpec.describe Blacklight::Solr::Response::GroupResponse, :api do
   end
 end
 
-def create_response(response, params = {})
-  Blacklight::Solr::Response.new(response, params)
-end
-
 def sample_response
   { "responseHeader" => { "params" => { "rows" => 3, "group.limit" => 5 } },
     "grouped" =>

data/spec/models/blacklight/solr/response/group_spec.rb

@@ -7,8 +7,16 @@ RSpec.describe Blacklight::Solr::Response::Group, :api do
     group.groups.first
   end
 
+  let(:search_builder) do
+    Blacklight::SearchBuilder.new(view_context)
+  end
+
+  let(:view_context) do
+    double("View context", blacklight_config: CatalogController.blacklight_config.deep_copy)
+  end
+
   let(:response) do
-    create_response(sample_response)
+    Blacklight::Solr::Response.new(sample_response, search_builder)
   end
 
   let(:group) do
@@ -51,10 +59,6 @@ RSpec.describe Blacklight::Solr::Response::Group, :api do
   end
 end
 
-def create_response(response, params = {})
-  Blacklight::Solr::Response.new(response, params)
-end
-
 def sample_response
   { "responseHeader" => { "params" => { "rows" => 3, "group.limit" => 5 } },
     "grouped" =>

data/spec/models/blacklight/solr/response_spec.rb

@@ -3,16 +3,17 @@
 require 'rspec-benchmark'
 
 RSpec.describe Blacklight::Solr::Response, :api do
-  let(:raw_response) { eval(mock_query_response) }
-
-  let(:config) { Blacklight::Configuration.new }
-
-  let(:r) do
+  subject(:r) do
     described_class.new(raw_response,
-                        raw_response['params'],
+                        request_params,
                         blacklight_config: config)
   end
 
+  let(:raw_response) { eval(mock_query_response) }
+
+  let(:config) { Blacklight::Configuration.new }
+  let(:request_params) { raw_response['params'] }
+
   it 'creates a valid response' do
     expect(r).to respond_to(:header)
   end
@@ -134,113 +135,144 @@ RSpec.describe Blacklight::Solr::Response, :api do
     expect(facet.name).to eq 'cat'
   end
 
-  it 'provides the responseHeader params' do
-    raw_response = eval(mock_query_response)
-    raw_response['responseHeader']['params']['test'] = :test
-    r = described_class.new(raw_response, raw_response['params'])
-    expect(r.params['test']).to eq :test
+  context 'with responseHeader params' do
+    let(:raw_response) do
+      eval(mock_query_response).tap do |resp|
+        resp['responseHeader']['params']['test'] = :test
+      end
+    end
+
+    it 'provides the responseHeader params' do
+      expect(r.params['test']).to eq :test
+    end
   end
 
-  it 'extracts json params' do
-    raw_response = eval(mock_query_response)
-    raw_response['responseHeader']['params']['test'] = 'from query'
-    raw_response['responseHeader']['params'].delete('rows')
-    raw_response['responseHeader']['params']['json'] = { limit: 5, params: { test: 'from json params' } }.to_json
-    r = described_class.new(raw_response, raw_response['params'])
-    expect(r.params['test']).to eq 'from query'
-    expect(r.rows).to eq 5
+  context 'with json params' do
+    let(:raw_response) do
+      eval(mock_response_with_spellcheck).tap do |resp|
+        resp['responseHeader']['params']['test'] = 'from query'
+        resp['responseHeader']['params'].delete('rows')
+        resp['responseHeader']['params']['json'] = { limit: 5, params: { test: 'from json params' } }.to_json
+      end
+    end
+
+    it 'extracts json params' do
+      expect(r.params['test']).to eq 'from query'
+      expect(r.rows).to eq 5
+    end
   end
 
   it 'provides the solr-returned params and "rows" should be 11' do
-    raw_response = eval(mock_query_response)
-    r = described_class.new(raw_response, {})
     expect(r.params[:rows].to_s).to eq '11'
     expect(r.params[:sort]).to eq 'title_si asc, pub_date_si desc'
   end
 
-  it 'provides the ruby request params if responseHeader["params"] does not exist' do
-    raw_response = eval(mock_query_response)
-    raw_response.delete 'responseHeader'
-    r = described_class.new(raw_response, rows: 999, sort: 'score desc, pub_date_si desc, title_si asc')
-    expect(r.params[:rows].to_s).to eq '999'
-    expect(r.params[:sort]).to eq 'score desc, pub_date_si desc, title_si asc'
+  context 'when responseHeader["params"] does not exist' do
+    before do
+      raw_response.delete 'responseHeader'
+    end
+
+    let(:request_params) { { rows: 999, sort: 'score desc, pub_date_si desc, title_si asc' } }
+
+    it 'provides the ruby request params' do
+      expect(r.params[:rows].to_s).to eq '999'
+      expect(r.params[:sort]).to eq 'score desc, pub_date_si desc, title_si asc'
+    end
   end
 
-  it 'provides spelling suggestions for regular spellcheck results' do
-    raw_response = eval(mock_response_with_spellcheck)
-    r = described_class.new(raw_response, {})
-    expect(r.spelling.words).to include("dell")
-    expect(r.spelling.words).to include("ultrasharp")
+  context 'with regular spellcheck results' do
+    let(:raw_response) { eval(mock_response_with_spellcheck) }
+    let(:request_params) { {} }
+
+    it 'provides spelling suggestions' do
+      expect(r.spelling.words).to include("dell")
+      expect(r.spelling.words).to include("ultrasharp")
+    end
   end
 
-  it 'provides spelling suggestions for extended spellcheck results' do
-    raw_response = eval(mock_response_with_spellcheck_extended)
-    r = described_class.new(raw_response, {})
-    expect(r.spelling.words).to include("dell")
-    expect(r.spelling.words).to include("ultrasharp")
+  context 'with extended spellcheck results' do
+    let(:raw_response) { eval(mock_response_with_spellcheck_extended) }
+    let(:request_params) { {} }
+
+    it 'provides spelling suggestions' do
+      expect(r.spelling.words).to include("dell")
+      expect(r.spelling.words).to include("ultrasharp")
+    end
   end
 
-  it 'provides no spelling suggestions when extended results and suggestion frequency is the same as original query frequency' do
-    raw_response = eval(mock_response_with_spellcheck_same_frequency)
-    r = described_class.new(raw_response, {})
-    expect(r.spelling.words).to eq []
+  context 'when extended results and suggestion frequency is the same as original query frequency' do
+    let(:raw_response) { eval(mock_response_with_spellcheck_same_frequency) }
+    let(:request_params) { {} }
+
+    it 'provides no spelling suggestions' do
+      expect(r.spelling.words).to eq []
+    end
   end
 
-  context "pre solr 5 spellcheck collation syntax" do
+  context "with pre solr 5 spellcheck collation syntax" do
+    let(:raw_response) { eval(mock_response_with_spellcheck_collation) }
+    let(:request_params) { {} }
+
     it 'provides spelling suggestions for a regular spellcheck results with a collation' do
-      raw_response = eval(mock_response_with_spellcheck_collation)
-      r = described_class.new(raw_response, {})
       expect(r.spelling.words).to include("dell")
       expect(r.spelling.words).to include("ultrasharp")
     end
 
     it 'provides spelling suggestion collation' do
-      raw_response = eval(mock_response_with_spellcheck_collation)
-      r = described_class.new(raw_response, {})
       expect(r.spelling.collation).to eq 'dell ultrasharp'
     end
   end
 
-  context "solr 5 spellcheck collation syntax" do
+  context "with solr 5 spellcheck collation syntax" do
+    let(:raw_response) { eval(mock_response_with_spellcheck_collation_solr5) }
+    let(:request_params) { {} }
+
     it 'provides spelling suggestions for a regular spellcheck results with a collation' do
-      raw_response = eval(mock_response_with_spellcheck_collation_solr5)
-      r = described_class.new(raw_response, {})
       expect(r.spelling.words).to include("dell")
       expect(r.spelling.words).to include("ultrasharp")
     end
 
     it 'provides spelling suggestion collation' do
-      raw_response = eval(mock_response_with_spellcheck_collation_solr5)
-      r = described_class.new(raw_response, {})
       expect(r.spelling.collation).to eq 'dell ultrasharp'
     end
   end
 
-  context 'solr 6.5 spellcheck collation syntax' do
+  context 'with solr 6.5 spellcheck collation syntax' do
+    let(:raw_response) { eval(mock_response_with_spellcheck_collation_solr65) }
+    let(:request_params) { {} }
+
     it 'provides spelling suggestions for a regular spellcheck results with a collation' do
-      raw_response = eval(mock_response_with_spellcheck_collation_solr65)
-      r = described_class.new(raw_response, {})
       expect(r.spelling.words).to include("dell")
       expect(r.spelling.words).to include("ultrasharp")
     end
   end
 
-  it "provides MoreLikeThis suggestions" do
-    raw_response = eval(mock_response_with_more_like_this)
-    r = described_class.new(raw_response, {})
-    expect(r.more_like(double(id: '79930185'))).to have(2).items
+  context 'with moreLikeThis suggstions' do
+    let(:raw_response) { eval(mock_response_with_more_like_this) }
+    let(:request_params) { {} }
+
+    it "provides MoreLikeThis suggestions" do
+      expect(r.more_like(double(id: '79930185'))).to have(2).items
+    end
   end
 
-  it "is empty when the response has no results" do
-    r = described_class.new({}, {})
-    allow(r).to receive_messages(total: 0)
-    expect(r).to be_empty
+  context 'with no results' do
+    let(:raw_response) { {} }
+    let(:request_params) { {} }
+
+    it "is empty when the response has no results" do
+      expect(r).to be_empty
+    end
   end
 
   describe "#export_formats" do
-    it "collects the unique export formats for the current response" do
-      r = described_class.new({}, {})
+    before do
+      # rubocop:disable RSpec/SubjectStub
       allow(r).to receive_messages(documents: [double(export_formats: { a: 1, b: 2 }), double(export_formats: { b: 1, c: 2 })])
+      # rubocop:enable RSpec/SubjectStub
+    end
+
+    it "collects the unique export formats for the current response" do
       expect(r.export_formats).to include :a, :b
     end
   end

data/spec/models/blacklight/solr/search_builder_behavior_spec.rb

@@ -523,68 +523,55 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
     end
   end
 
-  describe "#facet_value_to_fq_string" do
-    it "uses the configured field name" do
-      blacklight_config.add_facet_field :facet_key, field: "facet_name"
-      expect(subject.send(:facet_value_to_fq_string, "facet_key", "my value")).to eq "{!term f=facet_name}my value"
-    end
-
-    it "uses the raw handler for strings" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", "my value")).to eq "{!term f=facet_name}my value"
-    end
-
-    it "passes booleans through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", true)).to eq '{!term f=facet_name}true'
-    end
-
-    it "passes boolean-like strings through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", "true")).to eq '{!term f=facet_name}true'
-    end
+  describe "#add_facets_for_advanced_search_form" do
+    let(:solr_parameters) { Blacklight::Solr::Request.new }
+    let(:mock_controller) { instance_double(CatalogController, action_name: 'advanced_search') }
+    let(:mock_search_state) { instance_double(Blacklight::SearchState, controller: mock_controller) }
 
-    it "passes integers through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", 1)).to eq '{!term f=facet_name}1'
-    end
-
-    it "passes integer-like strings through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", "1")).to eq '{!term f=facet_name}1'
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", -1)).to eq '{!term f=facet_name}-1'
-    end
-
-    it "passes floats through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", 1.11)).to eq '{!term f=facet_name}1.11'
+    before do
+      allow(search_builder).to receive(:search_state).and_return(mock_search_state)
     end
 
-    it "passes floats in strings through" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", "1.11")).to eq '{!term f=facet_name}1.11'
-    end
+    context "when action is advanced_search and form_solr_parameters are configured" do
+      before do
+        blacklight_config.advanced_search.enabled = true
+        blacklight_config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'count',
+          'facet.field' => %w[format subject_ssim],
+          'f.format.facet.limit' => -1,
+          'f.subject_ssim.facet.limit' => -1
+        }
+      end
 
-    context 'date handling' do
-      before { allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(date: true, query: nil, tag: nil, field: 'facet_name')) }
+      it "merges advanced search form parameters into solr parameters" do
+        solr_parameters['existing.param'] = 'keep_me'
+        subject.add_facets_for_advanced_search_form(solr_parameters)
 
-      it "passes date-type fields through" do
-        expect(subject.send(:facet_value_to_fq_string, "facet_name", "2012-01-01")).to eq '{!term f=facet_name}2012-01-01'
-        expect(subject.send(:facet_value_to_fq_string, "facet_name", "2003-04-09T00:00:00Z")).to eq '{!term f=facet_name}2003-04-09T00:00:00Z'
+        expect(solr_parameters['facet.sort']).to eq 'count'
+        expect(solr_parameters['facet.field']).to eq %w[format subject_ssim]
+        expect(solr_parameters['f.format.facet.limit']).to eq(-1)
+        expect(solr_parameters['f.subject_ssim.facet.limit']).to eq(-1)
+        expect(solr_parameters['existing.param']).to eq 'keep_me'
       end
+    end
 
-      it "formats Date objects correctly" do
-        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(date: nil, query: nil, tag: nil, field: 'facet_name'))
-        d = DateTime.parse("2003-04-09T00:00:00")
-        expect(subject.send(:facet_value_to_fq_string, "facet_name", d)).to eq '{!term f=facet_name}2003-04-09T00:00:00Z'
+    context "when action is not advanced_search" do
+      before do
+        allow(mock_controller).to receive(:action_name).and_return('index')
+        blacklight_config.advanced_search.enabled = true
+        blacklight_config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'count',
+          'facet.field' => ['format']
+        }
       end
-    end
 
-    it "handles range requests" do
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", 1..5)).to eq "facet_name:[1 TO 5]"
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", 1..nil)).to eq "facet_name:[1 TO *]"
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", nil..5)).to eq "facet_name:[* TO 5]"
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", nil..nil)).to eq "facet_name:[* TO *]"
-    end
+      it "does not merge advanced search form parameters" do
+        solr_parameters['f.format.facet.limit'] = 21
 
-    it "adds tag local parameters" do
-      allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(query: nil, tag: 'asdf', date: nil, field: 'facet_name'))
+        subject.add_facets_for_advanced_search_form(solr_parameters)
 
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", true)).to eq "{!term f=facet_name tag=asdf}true"
-      expect(subject.send(:facet_value_to_fq_string, "facet_name", "my value")).to eq "{!term f=facet_name tag=asdf}my value"
+        expect(solr_parameters['f.format.facet.limit']).to eq 21
+      end
     end
   end
 
@@ -902,12 +889,6 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   end
 
   context 'with advanced search clause parameters' do
-    before do
-      blacklight_config.search_fields.each_value do |v|
-        v.clause_params = { edismax: v.solr_parameters.dup }
-      end
-    end
-
     let(:user_params) { { op: 'must', clause: { '0': { field: 'title', query: 'the book' }, '1': { field: 'author', query: 'the person' } } } }
 
     it "has proper solr parameters" do

data/spec/models/solr_document_spec.rb

@@ -37,7 +37,11 @@ RSpec.describe SolrDocument, :api do
                           title_tesim: ['Good Omens'])
     end
 
-    it { is_expected.to end_with "_source: {\"id\"=>\"123\", \"title_tesim\"=>[\"Good Omens\"]}>" }
+    if RUBY_VERSION > '3.4'
+      it { is_expected.to end_with "_source: {\"id\" => \"123\", \"title_tesim\" => [\"Good Omens\"]}>" }
+    else
+      it { is_expected.to end_with "_source: {\"id\"=>\"123\", \"title_tesim\"=>[\"Good Omens\"]}>" }
+    end
   end
 
   describe '.attribute' do