blacklight 9.0.0.beta1 → 9.0.0.beta2

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

@@ -43,7 +43,7 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   end
 
   context "with a complex parameter environment" do
-    subject { search_builder.with(user_params).processed_parameters }
+    subject { search_builder.with(user_params).send(:processed_parameters) }
 
     let(:user_params) do
       { :search_field => "test_field", :q => "test query", "facet.field" => "extra_facet" }
@@ -90,7 +90,7 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   # SPECS for actual search parameter generation
   describe "#processed_parameters" do
     subject do
-      search_builder.with(user_params).processed_parameters
+      search_builder.with(user_params).send(:processed_parameters)
     end
 
     context "when search_params_logic is customized" do
@@ -523,71 +523,6 @@ 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
-
-    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
-
   describe "#add_facet_fq_to_solr" do
     it "converts a String fq into an Array" do
       solr_parameters = { fq: 'a string' }
@@ -731,166 +666,6 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
     end
   end
 
-  describe "#add_facet_paging_to_solr" do
-    let(:facet_field) { 'format' }
-    let(:sort_key) { Blacklight::Solr::FacetPaginator.request_keys[:sort] }
-    let(:page_key) { Blacklight::Solr::FacetPaginator.request_keys[:page] }
-    let(:prefix_key) { Blacklight::Solr::FacetPaginator.request_keys[:prefix] }
-
-    let(:blacklight_config) do
-      Blacklight::Configuration.new do |config|
-        config.add_facet_fields_to_solr_request!
-        config.add_facet_field 'format'
-        config.add_facet_field 'format_ordered', sort: :count
-        config.add_facet_field 'format_limited', limit: 5
-        config.add_facet_field 'format_more_limited', limit: 5, more_limit: 50
-      end
-    end
-
-    let(:solr_parameters) do
-      solr_parameters = Blacklight::Solr::Request.new
-      subject.facet(facet_field).add_facet_paging_to_solr(solr_parameters)
-      solr_parameters
-    end
-
-    it 'sets rows to 0' do
-      expect(solr_parameters[:rows]).to eq 0
-    end
-
-    it 'sets facets requested to facet_field argument' do
-      expect(solr_parameters[:'facet.field']).to eq facet_field
-    end
-
-    it 'defaults offset to 0' do
-      expect(solr_parameters[:"f.#{facet_field}.facet.offset"]).to eq 0
-    end
-
-    context 'when offset is manually set' do
-      let(:user_params) { { page_key => 2 } }
-
-      it 'uses offset manually set, and converts it to an integer' do
-        expect(solr_parameters[:"f.#{facet_field}.facet.offset"]).to eq 20
-      end
-    end
-
-    context 'for a field with a configured more_limit' do
-      let(:facet_field) { 'format_more_limited' }
-
-      it 'uses the more_limit configuration' do
-        expect(solr_parameters[:"f.#{facet_field}.facet.limit"]).to eq 51
-      end
-    end
-
-    context 'for a field with a param key different from the field name' do
-      let(:user_params) { { page_key => 2, 'facet.sort': 'index', 'facet.prefix': 'x' } }
-      let(:facet_field) { 'param_key' }
-
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.tap do |config|
-          config.add_facet_field key: 'param_key', field: 'solr_field', more_limit: 50, ex: 'other'
-
-          config.add_facet_fields_to_solr_request!
-        end
-      end
-
-      it "uses the configured solr field name in queries" do
-        expect(solr_parameters).to include 'f.solr_field.facet.limit': 51,
-                                           'f.solr_field.facet.offset': 50,
-                                           'f.solr_field.facet.sort': 'index',
-                                           'f.solr_field.facet.prefix': 'x',
-                                           'facet.field': '{!ex=other}solr_field'
-      end
-    end
-
-    it 'defaults limit to 20' do
-      expect(solr_parameters[:"f.#{facet_field}.facet.limit"]).to eq 21
-    end
-
-    it 'uses the default sort' do
-      expect(solr_parameters[:"f.#{facet_field}.facet.sort"]).to be_blank
-    end
-
-    context 'when sort is provided' do
-      let(:user_params) { { sort_key => 'index' } }
-
-      it 'uses sort provided in the parameters' do
-        expect(solr_parameters[:"f.#{facet_field}.facet.sort"]).to eq 'index'
-      end
-    end
-
-    context 'when a prefix is provided' do
-      let(:user_params) { { prefix_key => 'A' } }
-
-      it 'includes the prefix in the query' do
-        expect(solr_parameters[:"f.#{facet_field}.facet.prefix"]).to eq 'A'
-      end
-    end
-  end
-
-  describe "#add_facet_suggestion_parameters" do
-    it "does not add anything when the builder has no facet_suggestion_query and no facet" do
-      expect(subject.facet).to be_nil
-      expect(subject.facet_suggestion_query).to be_nil
-      solr_params = Blacklight::Solr::Request.new
-
-      expect do
-        subject.add_facet_suggestion_parameters(solr_params)
-      end.not_to(change { solr_params })
-    end
-
-    it "does not add anything when the builder has a facet_suggestion_query but no facet" do
-      subject.facet_suggestion_query = 'artic'
-      expect(subject.facet_suggestion_query).to eq 'artic'
-      expect(subject.facet).to be_nil
-      solr_params = Blacklight::Solr::Request.new
-
-      expect do
-        subject.add_facet_suggestion_parameters(solr_params)
-      end.not_to(change { solr_params })
-    end
-
-    it "does not add anything when the builder has a facet but no facet_suggestion_query" do
-      subject.facet = 'subject_facet'
-      expect(subject.facet_suggestion_query).to be_nil
-      expect(subject.facet).to eq 'subject_facet'
-      solr_params = Blacklight::Solr::Request.new
-
-      expect do
-        subject.add_facet_suggestion_parameters(solr_params)
-      end.not_to(change { solr_params })
-    end
-
-    it "adds the facet_suggestion_query to facet.contains" do
-      subject.facet = 'subject_facet'
-      subject.facet_suggestion_query = 'artic'
-      solr_params = Blacklight::Solr::Request.new
-
-      subject.add_facet_suggestion_parameters(solr_params)
-
-      expect(solr_params[:'facet.contains']).to eq 'artic'
-    end
-
-    it "adds the first part of facet_suggestion_query to facet.contains if it is extremely long" do
-      subject.facet = 'subject_facet'
-      subject.facet_suggestion_query = 'Call me Ishmael. Some years ago—never mind how long precisely'
-      solr_params = Blacklight::Solr::Request.new
-
-      subject.add_facet_suggestion_parameters(solr_params)
-
-      expect(solr_params[:'facet.contains']).to eq 'Call me Ishmael. Some years ago—never mind how long'
-    end
-
-    it "adds facet.contains.ignoreCase" do
-      subject.facet = 'subject_facet'
-      subject.facet_suggestion_query = 'artic'
-      solr_params = Blacklight::Solr::Request.new
-
-      subject.add_facet_suggestion_parameters(solr_params)
-
-      expect(solr_params[:'facet.contains.ignoreCase']).to be true
-    end
-  end
-
   describe "#with_tag_ex" do
     it "adds an !ex local parameter if the facet configuration requests it" do
       expect(subject.with_ex_local_param("xyz", "some-value")).to eq "{!ex=xyz}some-value"

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

data/spec/services/blacklight/search_service_spec.rb

@@ -12,22 +12,19 @@ RSpec.describe Blacklight::SearchService, :api do
   subject { service }
 
   let(:context) { { whatever: :value } }
-  let(:service) { described_class.new(config: blacklight_config, user_params: user_params, **context) }
+  let(:search_state) { Blacklight::SearchState.new(user_params, blacklight_config) }
+  let(:service) { described_class.new(config: blacklight_config, search_state: search_state, **context) }
   let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
   let(:user_params) { {} }
 
-  let(:blacklight_config) { Blacklight::Configuration.new }
-  let(:copy_of_catalog_config) { CatalogController.blacklight_config.deep_copy }
-  let(:blacklight_solr) { RSolr.connect(Blacklight.connection_config.except(:adapter)) }
+  let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
 
   let(:all_docs_query) { '' }
   let(:no_docs_query) { 'zzzzzzzzzzzz' }
-  #  f[format][]=Book&f[language_facet][]=English
   let(:single_facet) { { format: 'Book' } }
 
   before do
     allow(service).to receive(:repository).and_return(repository)
-    service.repository.connection = blacklight_solr
   end
 
   describe '#search_builder_class' do
@@ -39,8 +36,7 @@ RSpec.describe Blacklight::SearchService, :api do
 
     context 'when the search_builder_class is passed in' do
       let(:klass) { double("Search builder") }
-
-      let(:service) { described_class.new(config: blacklight_config, user_params: user_params, search_builder_class: klass) }
+      let(:context) { { search_builder_class: klass } }
 
       it 'uses the passed value' do
         expect(subject).to eq klass
@@ -50,16 +46,15 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR QUERY
   describe 'Search Results', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
-
     describe 'for a sample query returning results' do
       let(:user_params) { { q: all_docs_query } }
+      let(:blacklight_solr) { service.repository.connection }
 
       it "uses the configured request handler" do
         allow(blacklight_config).to receive(:default_solr_params).and_return(qt: 'custom_request_handler')
         allow(blacklight_solr).to receive(:send_and_receive) do |path, params|
           expect(path).to eq 'select'
-          expect(params[:params]['facet.field']).to eq ["format", "{!ex=pub_date_ssim_single}pub_date_ssim", "subject_ssim", "language_ssim", "lc_1letter_ssim", "subject_geo_ssim", "subject_era_ssim"]
+          expect(params[:params]['facet.field']).to contain_exactly "format", "{!ex=pub_date_ssim_single}pub_date_ssim", "subject_ssim", "language_ssim", "lc_1letter_ssim", "subject_geo_ssim", "subject_era_ssim"
           expect(params[:params]["facet.query"]).to eq ["pub_date_ssim:[#{5.years.ago.year} TO *]", "pub_date_ssim:[#{10.years.ago.year} TO *]", "pub_date_ssim:[#{25.years.ago.year} TO *]"]
           expect(params[:params]).to include('rows' => 10, 'qt' => "custom_request_handler", 'q' => "", "f.subject_ssim.facet.limit" => 21, 'sort' => "score desc, pub_date_si desc, title_si asc")
         end.and_return('response' => { 'docs' => [] })
@@ -68,7 +63,6 @@ RSpec.describe Blacklight::SearchService, :api do
     end
 
     describe "for a query returning a grouped response" do
-      let(:blacklight_config) { copy_of_catalog_config }
       let(:user_params) { { q: all_docs_query } }
 
       before do
@@ -82,7 +76,6 @@ RSpec.describe Blacklight::SearchService, :api do
     end
 
     describe "for a query returning multiple groups", :integration do
-      let(:blacklight_config) { copy_of_catalog_config }
       let(:user_params) { { q: all_docs_query } }
 
       before do
@@ -140,7 +133,6 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR FACETS
   describe 'Facets in Search Results for All Docs Query', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
     let(:user_params) { { q: all_docs_query } }
 
     before do
@@ -185,7 +177,6 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR PAGING
   describe 'Paging', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
     let(:user_params) { { q: all_docs_query } }
 
     it 'starts with first results by default' do
@@ -379,18 +370,6 @@ RSpec.describe Blacklight::SearchService, :api do
   # TODO: maybe eventually check other types of solr requests
   #  more like this
   #  nearby on shelf
-  it "raises a Blacklight exception if RSolr can't connect to the Solr instance" do
-    allow(blacklight_solr).to receive(:send_and_receive).and_raise(Errno::ECONNREFUSED)
-    expect { service.repository.search }.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(blacklight_solr).to receive(:send_and_receive).and_raise(rsolr_timeout)
-    expect { service.repository.search }.to raise_exception(Blacklight::Exceptions::RepositoryTimeout, /Timeout connecting to Solr instance/)
-  end
 
   describe "#previous_and_next_documents_for_search" do
     let(:user_params) { { q: '', per_page: 100 } }

data/spec/spec_helper.rb

@@ -21,7 +21,6 @@ require 'selenium-webdriver'
 require 'equivalent-xml'
 require 'axe-rspec'
 
-require 'rsolr'
 require 'blacklight'
 
 Capybara.javascript_driver = :headless_chrome

data/spec/support/view_component_test_helpers.rb

@@ -1,24 +1,6 @@
 # frozen_string_literal: true
 
 module ViewComponentTestHelpers
-  # Work around for https://github.com/teamcapybara/capybara/issues/2466
-  def render_inline_to_capybara_node(component)
-    Capybara::Node::Simple.new(render_inline(component).to_s)
-  end
-
-  # Work-around for https://github.com/ViewComponent/view_component/pull/1661
-  # which made the component test's controller method (more) private. This makes
-  # it available so we can set up controller-level state for our tests.
-  def controller
-    # ViewComponent 2.x
-    return super if defined?(super)
-
-    # ViewComponent 3.x
-    return vc_test_controller if defined?(vc_test_controller)
-
-    ApplicationController.new.extend(Rails.application.routes.url_helpers)
-  end
-
   # Nokogiri 1.15.0 upgrades the vendored libxml2 from v2.10.4 to v2.11.3
   # libxml2 v2.11.0 introduces a change to parsing HTML href attributes
   # in nokogiri < 1.15, brackets in href attributes are escaped:

data/spec/views/catalog/facet.html.erb_spec.rb

@@ -4,15 +4,21 @@ RSpec.describe 'catalog/facet.html.erb' do
   let(:display_facet) { double }
   let(:blacklight_config) { Blacklight::Configuration.new }
   let(:component) { instance_double(Blacklight::FacetComponent) }
+  let(:pagination) { instance_double(Blacklight::FacetFieldPaginationComponent) }
+  let(:facet_filters) { instance_double(Blacklight::Facets::FiltersComponent) }
 
   before do
     allow(Blacklight::FacetComponent).to receive(:new).and_return(component)
+    allow(Blacklight::Facets::FiltersComponent).to receive(:new).and_return(facet_filters)
+    allow(Blacklight::FacetFieldPaginationComponent).to receive(:new).and_return(pagination)
+
     allow(view).to receive(:render).and_call_original
     allow(view).to receive(:render).with(component)
+    allow(view).to receive(:render).with(facet_filters)
+    allow(view).to receive(:render).with(pagination)
 
     blacklight_config.add_facet_field 'xyz', label: "Facet title"
     allow(view).to receive(:blacklight_config).and_return(blacklight_config)
-    stub_template 'catalog/_facet_pagination.html.erb' => 'pagination'
     assign :facet, blacklight_config.facet_fields['xyz']
     assign :display_facet, display_facet
   end
@@ -22,9 +28,10 @@ RSpec.describe 'catalog/facet.html.erb' do
     expect(rendered).to have_css 'h1', text: "Facet title"
   end
 
-  it "renders facet pagination" do
+  it "renders the subcomponents" do
     render
-    expect(rendered).to have_content 'pagination'
+    expect(view).to have_received(:render).with(facet_filters)
+    expect(view).to have_received(:render).with(pagination).twice
   end
 
   it "renders the facet limit" do

data/spec/views/catalog/index.atom.builder_spec.rb

@@ -14,13 +14,16 @@ RSpec.describe "catalog/index" do
   end
 
   let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
+  let(:search_builder) { Blacklight::SearchBuilder.new(view) }
+  let(:response) { Blacklight::Solr::Response.new({ response: { numFound: 30 } }, search_builder) }
 
   before do
-    @response = Blacklight::Solr::Response.new({ response: { numFound: 30 } }, start: 10, rows: 10)
+    allow(view).to receive_messages(action_name: 'index', blacklight_config: blacklight_config)
+    @response = response
     allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
-    allow(@response).to receive(:documents).and_return(document_list)
+    allow(search_builder).to receive_messages(start: 10, rows: 10)
+    allow(response).to receive(:documents).and_return(document_list)
     params['content_format'] = 'some_format'
-    allow(view).to receive_messages(action_name: 'index', blacklight_config: blacklight_config)
   end
 
   # We need to use rexml to test certain things that have_tag wont' test

data/spec/views/catalog/index.html.erb_spec.rb

@@ -20,12 +20,14 @@ RSpec.describe "catalog/index.html.erb" do
     before do
       stub_template "catalog/_results_pagination.html.erb" => ""
       allow(view).to receive_messages(has_search_parameters?: true, blacklight_config: Blacklight::Configuration.new)
+      allow(search_builder).to receive_messages(start: 10, rows: 10)
       allow(controller).to receive_messages(blacklight_config: Blacklight::Configuration.new)
 
       @response = response
     end
 
-    let(:response) { Blacklight::Solr::Response.new({ response: { numFound: 30 } }, start: 10, rows: 10) }
+    let(:search_builder) { Blacklight::SearchBuilder.new(view) }
+    let(:response) { Blacklight::Solr::Response.new({ response: { numFound: 30 } }, search_builder) }
 
     it "renders the search_header partial" do
       render