blacklight 9.0.0.beta1 → 9.0.0

data/spec/models/blacklight/configuration_spec.rb

@@ -1,8 +1,28 @@
 # frozen_string_literal: true
 
-RSpec.describe "Blacklight::Configuration", :api do
+RSpec.describe Blacklight::Configuration, :api do
   let(:config) do
-    Blacklight::Configuration.new
+    described_class.new
+  end
+
+  describe "#repository" do
+    context 'when the class is configured in blacklight.yml' do
+      it "uses the default repository class" do
+        expect(config.repository).to be_a(Blacklight::Solr::Repository)
+      end
+    end
+
+    context 'when the class is set in the configuration' do
+      let(:custom_repository_class) { Class.new(Blacklight::Solr::Repository) }
+
+      before do
+        config.repository_class = custom_repository_class
+      end
+
+      it "uses the custom repository class" do
+        expect(config.repository).to be_a(custom_repository_class)
+      end
+    end
   end
 
   it "supports arbitrary configuration values" do
@@ -17,14 +37,18 @@ RSpec.describe "Blacklight::Configuration", :api do
       expect(config).to be_a Blacklight::OpenStructWithHashAccess
     end
 
-    it "accepts a block for configuration" do
-      config = Blacklight::Configuration.new(a: 1) { |c| c.a = 2 }
+    context 'when passed a block' do
+      let(:config) do
+        described_class.new(a: 1) { |c| c.a = 2 }
+      end
 
-      expect(config.a).to eq 2
+      it "accepts a block for configuration" do
+        expect(config.a).to eq 2
 
-      config.configure { |c| c.a = 3 }
+        config.configure { |c| c.a = 3 }
 
-      expect(config.a).to eq 3
+        expect(config.a).to eq 3
+      end
     end
   end
 
@@ -84,11 +108,11 @@ RSpec.describe "Blacklight::Configuration", :api do
 
   describe "spell_max" do
     it "defaults to 5" do
-      expect(Blacklight::Configuration.new.spell_max).to eq 5
+      expect(config.spell_max).to eq 5
     end
 
     it "accepts config'd value" do
-      expect(Blacklight::Configuration.new(spell_max: 10).spell_max).to eq 10
+      expect(described_class.new(spell_max: 10).spell_max).to eq 10
     end
   end
 
@@ -181,9 +205,9 @@ RSpec.describe "Blacklight::Configuration", :api do
 
   describe "add alternative solr fields" do
     it "lets you define any arbitrary solr field" do
-      Blacklight::Configuration.define_field_access :my_custom_field
+      described_class.define_field_access :my_custom_field
 
-      config = Blacklight::Configuration.new do |config|
+      config = described_class.new do |config|
         config.add_my_custom_field 'qwerty', label: "asdf"
       end
 
@@ -191,9 +215,9 @@ RSpec.describe "Blacklight::Configuration", :api do
     end
 
     it "lets you define a field accessor that uses an existing field-type" do
-      Blacklight::Configuration.define_field_access :my_custom_facet_field, class: Blacklight::Configuration::FacetField
+      described_class.define_field_access :my_custom_facet_field, class: Blacklight::Configuration::FacetField
 
-      config = Blacklight::Configuration.new do |config|
+      config = described_class.new do |config|
         config.add_my_custom_facet_field 'qwerty', label: "asdf"
       end
 
@@ -406,13 +430,13 @@ RSpec.describe "Blacklight::Configuration", :api do
 
   describe "add_search_field" do
     it "accepts hash form" do
-      c = Blacklight::Configuration.new
+      c = described_class.new
       c.add_search_field(key: "my_search_key")
       expect(c.search_fields["my_search_key"]).not_to be_nil
     end
 
     it "accepts two-arg hash form" do
-      c = Blacklight::Configuration.new
+      c = described_class.new
 
       c.add_search_field("my_search_type",
                          key: "my_search_type",
@@ -428,7 +452,7 @@ RSpec.describe "Blacklight::Configuration", :api do
     end
 
     it "accepts block form" do
-      c = Blacklight::Configuration.new
+      c = described_class.new
 
       c.add_search_field("some_field") do |field|
         field.solr_parameters = { qf: "solr_field^10" }
@@ -443,7 +467,7 @@ RSpec.describe "Blacklight::Configuration", :api do
     end
 
     it "accepts SearchField object" do
-      c = Blacklight::Configuration.new
+      c = described_class.new
 
       f = Blacklight::Configuration::SearchField.new(foo: "bar")
 
@@ -481,7 +505,7 @@ RSpec.describe "Blacklight::Configuration", :api do
 
   describe "add_sort_field" do
     it "takes a hash" do
-      c = Blacklight::Configuration.new
+      c = described_class.new
       c.add_sort_field(key: "my_sort_key", sort: "score desc")
       expect(c.sort_fields["my_sort_key"]).not_to be_nil
     end
@@ -692,23 +716,149 @@ RSpec.describe "Blacklight::Configuration", :api do
 
   describe '.default_configuration' do
     it 'adds additional default configuration properties' do
-      Blacklight::Configuration.default_configuration do
-        Blacklight::Configuration.default_values[:a] = '123'
+      described_class.default_configuration do
+        described_class.default_values[:a] = '123'
       end
 
-      Blacklight::Configuration.default_configuration do
-        Blacklight::Configuration.default_values[:b] = 'abc'
+      described_class.default_configuration do
+        described_class.default_values[:b] = 'abc'
       end
 
-      expect(Blacklight::Configuration.default_values[:a]).to eq '123'
-      expect(Blacklight::Configuration.default_values[:b]).to eq 'abc'
+      expect(described_class.default_values[:a]).to eq '123'
+      expect(described_class.default_values[:b]).to eq 'abc'
     ensure
       # reset the default configuration
-      Blacklight::Configuration.default_values.delete(:a)
-      Blacklight::Configuration.default_values.delete(:b)
+      described_class.default_values.delete(:a)
+      described_class.default_values.delete(:b)
+
+      described_class.default_configuration.delete_at(1)
+      described_class.default_configuration.delete_at(2)
+    end
+  end
+
+  describe "#copy_search_field_config_to_advanced!" do
+    let(:config) { described_class.new }
+
+    before do
+      config.add_search_field('title',
+                              solr_parameters: {
+                                'spellcheck.dictionary': 'title',
+                                qf: '${title_qf}',
+                                pf: '${title_pf}'
+                              })
+      config.add_search_field('excluded_field',
+                              solr_parameters: { qf: '${excluded_qf}' },
+                              include_in_advanced_search: false)
+      config.add_search_field('already_configured',
+                              solr_parameters: { qf: '${configured_qf}' },
+                              clause_params: { edismax: { existing_custom: 'params' } })
+    end
+
+    it "copies solr_parameters to clause_params for eligible search fields" do
+      config.copy_search_field_config_to_advanced!
+
+      title_field = config.search_fields['title']
+      expect(title_field.clause_params).to be_present
+      expect(title_field.clause_params[:edismax]).to eq({ 'spellcheck.dictionary': 'title', qf: '${title_qf}', pf: '${title_pf}' })
+    end
+
+    it "skips fields with include_in_advanced_search set to false" do
+      config.copy_search_field_config_to_advanced!
+
+      excluded_field = config.search_fields['excluded_field']
+      expect(excluded_field.clause_params).to be_nil
+    end
+
+    it "skips fields that already have a clause_params config" do
+      config.copy_search_field_config_to_advanced!
+
+      already_configured_field = config.search_fields['already_configured']
+      expect(already_configured_field.clause_params).to eq({ edismax: { existing_custom: 'params' } })
+    end
+
+    it "handles fields with nil solr_parameters" do
+      config.add_search_field('no_solr_params')
+
+      expect { config.copy_search_field_config_to_advanced! }.not_to raise_error
 
-      Blacklight::Configuration.default_configuration.delete_at(1)
-      Blacklight::Configuration.default_configuration.delete_at(2)
+      field = config.search_fields['no_solr_params']
+      expect(field.clause_params).to be_present
+      expect(field.clause_params[:edismax]).to eq({})
+    end
+  end
+
+  describe "#copy_facet_field_config_to_advanced!" do
+    let(:config) { described_class.new }
+
+    before do
+      config.add_facet_field('format',
+                             field: 'format')
+      config.add_facet_field('subject_ssim')
+      config.add_facet_field('excluded_facet',
+                             field: 'excluded_field',
+                             include_in_advanced_search: false)
+      config.add_facet_field('query_facet',
+                             query: { 'recent' => { fq: 'pub_date_ssim:[2020 TO *]' } })
+      config.add_facet_field('pivot_facet',
+                             pivot: %w[author_ssim subject_ssim])
+      config.add_facet_field('range_facet',
+                             range: true,
+                             field: 'pub_date_ssim')
+    end
+
+    it "sets default facet.sort to 'count'" do
+      config.copy_facet_field_config_to_advanced!
+
+      expect(config.advanced_search.form_solr_parameters['facet.sort']).to eq 'count'
+    end
+
+    it "adds eligible facet fields to facet.field array" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).to eq(%w[format subject_ssim])
+    end
+
+    it "skips fields with include_in_advanced_search set to false" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).not_to include('excluded_field')
+    end
+
+    it "skips fields that are query, pivot, or range facets" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).not_to include('query_facet', 'pivot_facet', 'range_facet')
+    end
+
+    it "sets facet limit to -1 to show all values for eligible fields" do
+      config.copy_facet_field_config_to_advanced!
+
+      expect(config.advanced_search.form_solr_parameters['f.format.facet.limit']).to eq(-1)
+      expect(config.advanced_search.form_solr_parameters['f.subject_ssim.facet.limit']).to eq(-1)
+    end
+
+    context "preserving existing advanced search config if present" do
+      before do
+        config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'index',
+          'f.subject_ssim.facet.limit' => 50
+        }
+      end
+
+      it "preserves existing facet.limit configuration if set" do
+        config.copy_facet_field_config_to_advanced!
+
+        expect(config.advanced_search.form_solr_parameters['f.subject_ssim.facet.limit']).to eq(50)
+      end
+
+      it "preserves existing default facet.sort configuration if set" do
+        config.copy_facet_field_config_to_advanced!
+
+        expect(config.advanced_search.form_solr_parameters['facet.sort']).to eq('index')
+      end
     end
   end
 end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Solr::DefaultFilterQueryBuilder do
+  subject { described_class.new(blacklight_config: blacklight_config) }
+
+  let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
+
+  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
+
+    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'
+    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 '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 "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'
+      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'
+      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 "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'))
+
+      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"
+    end
+  end
+end

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

@@ -179,10 +179,6 @@ RSpec.describe "Blacklight::Solr::Document", :api do
         # registration in an after, sorry.
       end
 
-      it "registers format" do
-        expect(defined?("Mime::MOCK2")).to be_truthy
-      end
-
       it "registers as alias only" do
         expect(Mime::Type.lookup("application/mock2")).not_to equal Mime::Type.lookup_by_extension("mock2")
       end

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

@@ -44,26 +44,6 @@ RSpec.describe Blacklight::Solr::Repository, :api do
       end
     end
 
-    context "with legacy request handler-based configuration" do
-      before do
-        blacklight_config.document_solr_path = 'select'
-        blacklight_config.document_unique_id_param = :id
-      end
-
-      it "uses the provided :qt param" do
-        blacklight_config.document_solr_request_handler = 'xyz'
-        allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'abc' })).and_return(mock_response)
-        expect(subject.find("123", qt: 'abc')).to be_a Blacklight::Solr::Response
-      end
-
-      it "uses the :qt parameter from the default_document_solr_params" do
-        blacklight_config.default_document_solr_params[:qt] = 'abc'
-        blacklight_config.document_solr_request_handler = 'xyz'
-        allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'abc' })).and_return(mock_response)
-        expect(subject.find("123")).to be_a Blacklight::Solr::Response
-      end
-    end
-
     it "preserves the class of the incoming params" do
       doc_params = ActiveSupport::HashWithIndifferentAccess.new
       allow(subject.connection).to receive(:send_and_receive).with('get', anything).and_return(mock_response)
@@ -92,27 +72,42 @@ RSpec.describe Blacklight::Solr::Repository, :api do
   end
 
   describe "#search" do
+    context 'with positional params' do
+      it "uses the search-specific solr path" do
+        blacklight_config.solr_path = 'xyz'
+        allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
+        allow(Blacklight.deprecation).to receive(:warn)
+        expect(subject.search({})).to be_a Blacklight::Solr::Response
+      end
+    end
+
     it "uses the search-specific solr path" do
       blacklight_config.solr_path = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
-      expect(subject.search({})).to be_a Blacklight::Solr::Response
+      expect(subject.search(params: {})).to be_a Blacklight::Solr::Response
+    end
+
+    it "can be called with no args" do
+      blacklight_config.solr_path = 'xyz'
+      allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
+      expect(subject.search).to be_a Blacklight::Solr::Response
     end
 
     it "uses the default solr path" do
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
-      expect(subject.search({})).to be_a Blacklight::Solr::Response
+      expect(subject.search(params: {})).to be_a Blacklight::Solr::Response
     end
 
     it "uses a default :qt param" do
       blacklight_config.qt = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'xyz' })).and_return(mock_response)
-      expect(subject.search({})).to be_a Blacklight::Solr::Response
+      expect(subject.search(params: {})).to be_a Blacklight::Solr::Response
     end
 
     it "uses the provided :qt param" do
       blacklight_config.qt = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'abc' })).and_return(mock_response)
-      expect(subject.search(qt: 'abc')).to be_a Blacklight::Solr::Response
+      expect(subject.search(params: { qt: 'abc' })).to be_a Blacklight::Solr::Response
     end
 
     it "preserves the class of the incoming params" do
@@ -120,7 +115,7 @@ RSpec.describe Blacklight::Solr::Repository, :api do
       search_params[:q] = "query"
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
 
-      response = subject.search(search_params)
+      response = subject.search(params: search_params)
       expect(response).to be_a Blacklight::Solr::Response
       expect(response.params).to be_a ActiveSupport::HashWithIndifferentAccess
     end
@@ -133,7 +128,20 @@ RSpec.describe Blacklight::Solr::Repository, :api do
         expect(params[:method]).to eq :get
         expect(params[:params]).to include input_params
       end.and_return('response' => { 'docs' => [] })
-      subject.search(input_params)
+      subject.search(params: input_params)
+    end
+
+    it "raises a Blacklight exception if RSolr can't connect to the Solr instance" do
+      allow(repository.connection).to receive(:send_and_receive).and_raise(Errno::ECONNREFUSED)
+      expect { subject.search(params: {}) }.to raise_exception(/Unable to connect to Solr instance/)
+    end
+
+    it "raises a Blacklight exception if RSolr raises a timeout error connecting to Solr instance" do
+      rsolr_timeout = RSolr::Error::Timeout.new(nil, nil)
+      allow(rsolr_timeout).to receive(:to_s).and_return("mocked RSolr timeout")
+
+      allow(repository.connection).to receive(:send_and_receive).and_raise(rsolr_timeout)
+      expect { subject.search(params: {}) }.to raise_exception(Blacklight::Exceptions::RepositoryTimeout, /Timeout connecting to Solr instance/)
     end
   end
 
@@ -182,7 +190,7 @@ RSpec.describe Blacklight::Solr::Repository, :api do
           allow(subject.connection).to receive(:send_and_receive) do |path|
             expect(path).to eq 'xyz'
           end
-          subject.search(input_params)
+          subject.search(params: input_params)
         end
       end
 
@@ -195,7 +203,7 @@ RSpec.describe Blacklight::Solr::Repository, :api do
           allow(subject.connection).to receive(:send_and_receive) do |path|
             expect(path).to eq 'my-great-json'
           end
-          subject.search(input_params)
+          subject.search(params: input_params)
         end
       end
     end
@@ -205,7 +213,7 @@ RSpec.describe Blacklight::Solr::Repository, :api do
     let (:blacklight_config) { config = Blacklight::Configuration.new; config.http_method = :post; config }
 
     it "sends a post request to solr and get a response back" do
-      response = subject.search(q: all_docs_query)
+      response = subject.search(params: { q: all_docs_query })
       expect(response.docs.length).to be >= 1
     end
   end