blacklight 9.0.0.beta1 → 9.0.0.beta2

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,36 @@ 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 "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 +109,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 +122,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 +184,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 +197,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 +207,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

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