blacklight 6.14.0 → 7.0.0

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

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
-describe Blacklight::Solr::Repository do
+RSpec.describe Blacklight::Solr::Repository, api: true do
+  subject(:repository) do
+    described_class.new blacklight_config
+  end
 
   let :blacklight_config do
     CatalogController.blacklight_config.deep_copy
   end
 
-  subject do
-    Blacklight::Solr::Repository.new blacklight_config
-  end
-
   let :mock_response do
-    { response: { docs: [document]}}
+    { response: { docs: [document] } }
   end
 
   let :document do
@@ -19,40 +18,53 @@ describe Blacklight::Solr::Repository do
   end
 
   describe "#find" do
-    it "should use the document-specific solr path" do
+    it "uses the document-specific solr path" do
       blacklight_config.document_solr_path = 'abc'
       blacklight_config.solr_path = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('abc', anything).and_return(mock_response)
       expect(subject.find("123")).to be_a_kind_of Blacklight::Solr::Response
     end
 
-    it "should use the default 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.find("123")).to be_a_kind_of Blacklight::Solr::Response
-    end
-
-    it "should use a default :qt param" do
-      allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'document'})).and_return(mock_response)
+    it "uses a default :qt param" do
+      allow(subject.connection).to receive(:send_and_receive).with('get', hash_including(params: hash_including(ids: '123'))).and_return(mock_response)
       expect(subject.find("123", {})).to be_a_kind_of Blacklight::Solr::Response
     end
 
-    it "should use 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_kind_of Blacklight::Solr::Response
+    context "without a document solr path configured" do
+      before do
+        blacklight_config.document_solr_path = nil
+      end
+
+      it "uses the default 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.find("123")).to be_a_kind_of Blacklight::Solr::Response
+      end
     end
-    
-    it "should use 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_kind_of Blacklight::Solr::Response
+
+    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_kind_of 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_kind_of Blacklight::Solr::Response
+      end
     end
 
-    it "should preserve the class of the incoming params" do
+    it "preserves the class of the incoming params" do
       doc_params = ActiveSupport::HashWithIndifferentAccess.new
-      allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
+      allow(subject.connection).to receive(:send_and_receive).with('get', anything).and_return(mock_response)
       response = subject.find("123", doc_params)
       expect(response).to be_a_kind_of Blacklight::Solr::Response
       expect(response.params).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
@@ -60,34 +72,34 @@ describe Blacklight::Solr::Repository do
   end
 
   describe "#search" do
-    it "should use the search-specific solr path" 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)
       expect(subject.search({})).to be_a_kind_of Blacklight::Solr::Response
     end
 
-    it "should use the default solr path" do
+    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_kind_of Blacklight::Solr::Response
     end
 
-    it "should use a default :qt param" do
+    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)
+      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_kind_of Blacklight::Solr::Response
     end
 
-    it "should use the provided :qt param" do
+    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_kind_of Blacklight::Solr::Response
+      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_kind_of Blacklight::Solr::Response
     end
-    
-    it "should preserve the class of the incoming params" do
+
+    it "preserves the class of the incoming params" do
       search_params = ActiveSupport::HashWithIndifferentAccess.new
       search_params[:q] = "query"
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
-      
+
       response = subject.search(search_params)
       expect(response).to be_a_kind_of Blacklight::Solr::Response
       expect(response.params).to be_a_kind_of ActiveSupport::HashWithIndifferentAccess
@@ -97,20 +109,19 @@ describe Blacklight::Solr::Repository do
   describe "#send_and_receive" do
     describe "http_method configuration" do
       describe "using default" do
-
         it "defaults to get" do
           expect(blacklight_config.http_method).to eq :get
           allow(subject.connection).to receive(:send_and_receive) do |path, params|
             expect(path).to eq 'select'
             expect(params[:method]).to eq :get
             expect(params[:params]).to include(:q)
-          end.and_return({'response'=>{'docs'=>[]}})
-          subject.search(:q => @all_docs_query)
+          end.and_return('response' => { 'docs' => [] })
+          subject.search(q: @all_docs_query)
         end
       end
 
       describe "setting to post" do
-        let (:blacklight_config) {config = Blacklight::Configuration.new; config.http_method=:post; config}
+        let (:blacklight_config) { config = Blacklight::Configuration.new; config.http_method = :post; config }
 
         it "keep value set to post" do
           expect(blacklight_config.http_method).to eq :post
@@ -118,21 +129,25 @@ describe Blacklight::Solr::Repository do
             expect(path).to eq 'select'
             expect(params[:method]).to eq :post
             expect(params[:data]).to include(:q)
-          end.and_return({'response'=>{'docs'=>[]}})
-          subject.search(:q => @all_docs_query)
+          end.and_return('response' => { 'docs' => [] })
+          subject.search(q: @all_docs_query)
         end
       end
     end
   end
 
   describe "http_method configuration", integration: true do
-    let (:blacklight_config) {config = Blacklight::Configuration.new; config.http_method=:post; config}
+    let (:blacklight_config) { config = Blacklight::Configuration.new; config.http_method = :post; config }
 
-    it "should send a post request to solr and get a response back" do
-      response = subject.search(:q => @all_docs_query)
+    it "sends a post request to solr and get a response back" do
+      response = subject.search(q: @all_docs_query)
       expect(response.docs.length).to be >= 1
     end
   end
 
+  describe '#ping' do
+    subject { repository.ping }
 
+    it { is_expected.to be true }
+  end
 end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight::Solr::Request do
+RSpec.describe Blacklight::Solr::Request, api: true do
   before do
     subject[:qt] = 'hey'
     subject[:fq] = ["what's up.", "dood"]
@@ -15,23 +15,22 @@ describe Blacklight::Solr::Request do
     subject['spellcheck'] = "a"
     subject['spellcheck.q'] = "fleece"
     subject['f.title_facet.facet.limit'] = "vest"
-    subject['facet.field'] = [] 
-  end
-  it "should accept valid parameters" do
-    expect(subject.to_hash).to eq({"defType" => "had",
-       "f.title_facet.facet.limit" => "vest",
-       "fq" => ["what's up.", "dood"],
-       "group" => "I",
-       "hl" => "I",
-       "hl.fl" => "wish",
-       "q" => "what's",
-       "qt" => "hey",
-       "rows" => "Man",
-       "spellcheck" => "a",
-       "spellcheck.q" => "fleece",
-       "start" => "on",
-       "wt" => "going"
-    })
+    subject['facet.field'] = []
   end
 
+  it "accepts valid parameters" do
+    expect(subject.to_hash).to eq("defType" => "had",
+                                  "f.title_facet.facet.limit" => "vest",
+                                  "fq" => ["what's up.", "dood"],
+                                  "group" => "I",
+                                  "hl" => "I",
+                                  "hl.fl" => "wish",
+                                  "q" => "what's",
+                                  "qt" => "hey",
+                                  "rows" => "Man",
+                                  "spellcheck" => "a",
+                                  "spellcheck.q" => "fleece",
+                                  "start" => "on",
+                                  "wt" => "going")
+  end
 end

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

@@ -1,85 +1,85 @@
 # frozen_string_literal: true
 
-describe Blacklight::Solr::Response::Facets do
+RSpec.describe Blacklight::Solr::Response::Facets, api: true do
   describe Blacklight::Solr::Response::Facets::FacetField do
-
     describe "A field with default options" do
       subject { Blacklight::Solr::Response::Facets::FacetField.new "my_field", [] }
 
-      its(:name) { should eq "my_field" }
-      its(:limit) { should eq 100 }
-      its(:sort) { should eq 'count' }
-      its(:offset) { should eq 0 }
+      its(:name) { is_expected.to eq "my_field" }
+      its(:limit) { is_expected.to eq 100 }
+      its(:sort) { is_expected.to eq 'count' }
+      its(:offset) { is_expected.to eq 0 }
     end
 
     describe "A field with additional options" do
       subject { Blacklight::Solr::Response::Facets::FacetField.new "my_field", [], limit: 15, sort: 'alpha', offset: 23 }
 
-      its(:name) { should eq "my_field" }
-      its(:limit) { should eq 15 }
-      its(:sort) { should eq 'alpha' }
-      its(:offset) { should eq 23 }
+      its(:name) { is_expected.to eq "my_field" }
+      its(:limit) { is_expected.to eq 15 }
+      its(:sort) { is_expected.to eq 'alpha' }
+      its(:offset) { is_expected.to eq 23 }
     end
   end
 
   describe "#aggregations" do
+    subject { Blacklight::Solr::Response.new({ responseHeader: response_header, facet_counts: { facet_fields: [facet_field] } }, request_params) }
+
     let(:facet_field) { ['my_field', []] }
-    let(:response_header) { { params: request_params }}
-    let(:request_params) { Hash.new }
-    subject { Blacklight::Solr::Response.new({responseHeader: response_header, facet_counts: { facet_fields: [facet_field] }}, request_params)  }
+    let(:response_header) { { params: request_params } }
+    let(:request_params) { {} }
 
     describe "#limit" do
-      it "should extract a field-specific limit value" 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
       end
 
-      it "should extract a global limit value" do
+      it "extracts a global limit value" do
         request_params['facet.limit'] = "15"
         expect(subject.aggregations['my_field'].limit).to eq 15
       end
 
-      it "should be the solr default limit if no value is found" do
+      it "is the solr default limit if no value is found" do
         expect(subject.aggregations['my_field'].limit).to eq 100
       end
     end
 
     describe "#offset" do
-      it "should extract a field-specific offset value" 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
       end
 
-      it "should extract a global offset value" do
+      it "extracts a global offset value" do
         request_params['facet.offset'] = "15"
         expect(subject.aggregations['my_field'].offset).to eq 15
       end
 
-      it "should be nil if no value is found" do
+      it "is nil if no value is found" do
         expect(subject.aggregations['my_field'].offset).to eq 0
       end
     end
 
     describe "#sort" do
-      it "should extract a field-specific sort value" 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'
       end
 
-      it "should extract a global sort value" do
+      it "extracts a global sort value" do
         request_params['facet.sort'] = "alpha"
         expect(subject.aggregations['my_field'].sort).to eq 'alpha'
       end
 
-      it "should default to count if no value is found and the default limit is used" do
+      it "defaults to count if no value is found and the default limit is used" do
         expect(subject.aggregations['my_field'].sort).to eq 'count'
         expect(subject.aggregations['my_field'].count?).to eq true
       end
-      
-      it "should default to index if no value is found and the limit is unlimited" do
+
+      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 eq true
@@ -105,6 +105,8 @@ describe Blacklight::Solr::Response::Facets do
   end
 
   context "facet.missing" do
+    subject { Blacklight::Solr::Response.new(response, {}) }
+
     let(:response) do
       {
         facet_counts: {
@@ -114,10 +116,8 @@ describe Blacklight::Solr::Response::Facets do
         }
       }
     end
-    
-    subject { Blacklight::Solr::Response.new(response, {}) }
 
-    it "should mark the facet.missing field with a human-readable label and fq" do
+    it "marks the facet.missing field with a human-readable label and fq" do
       missing = subject.aggregations["some_field"].items.find { |i| i.value.nil? }
 
       expect(missing.label).to eq "[Missing]"
@@ -126,21 +126,23 @@ describe Blacklight::Solr::Response::Facets do
   end
 
   describe "query facets" do
-    let(:facet_config) { 
+    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+
+    let(:facet_config) do
       double(
         key: 'my_query_facet_field',
-        :query => {
-           'a_simple_query' => { :fq => 'field:search', :label => 'A Human Readable label'},
-           'another_query' => { :fq => 'field:different_search', :label => 'Label'},
-           'without_results' => { :fq => 'field:without_results', :label => 'No results for this facet'}
-           }
+        query: {
+          'a_simple_query' => { fq: 'field:search', label: 'A Human Readable label' },
+          'another_query' => { fq: 'field:different_search', label: 'Label' },
+          'without_results' => { fq: 'field:without_results', label: 'No results for this facet' }
+        }
       )
-    }
+    end
 
-    let(:blacklight_config) { double(facet_fields: { 'my_query_facet_field' => facet_config } )}
+    let(:blacklight_config) { double(facet_fields: { 'my_query_facet_field' => facet_config }) }
 
     let(:response) do
-      { 
+      {
         facet_counts: {
           facet_queries: {
             'field:search' => 10,
@@ -152,16 +154,14 @@ describe Blacklight::Solr::Response::Facets do
       }
     end
 
-    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
-
-    it"should convert the query facets into a double RSolr FacetField" do
+    it"converts the query facets into a double RSolr FacetField" do
       field = subject.aggregations['my_query_facet_field']
 
       expect(field).to be_a_kind_of Blacklight::Solr::Response::Facets::FacetField
 
-      expect(field.name).to eq'my_query_facet_field'
+      expect(field.name).to eq 'my_query_facet_field'
       expect(field.items.size).to eq 2
-      expect(field.items.map { |x| x.value }).to_not include 'field:not_appearing_in_the_config'
+      expect(field.items.map(&:value)).not_to include 'field:not_appearing_in_the_config'
 
       facet_item = field.items.find { |x| x.value == 'a_simple_query' }
 
@@ -172,31 +172,32 @@ describe Blacklight::Solr::Response::Facets do
   end
 
   describe "pivot facets" do
-    let(:facet_config) {
-      double(key: 'my_pivot_facet_field', query: nil, pivot: ['field_a', 'field_b'])
-    }
-    
-    let(:blacklight_config) { double(facet_fields: { 'my_pivot_facet_field' => facet_config } )}
+    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
+
+    let(:facet_config) do
+      double(key: 'my_pivot_facet_field', query: nil, pivot: %w[field_a field_b])
+    end
+
+    let(:blacklight_config) { double(facet_fields: { 'my_pivot_facet_field' => facet_config }) }
 
     let(:response) do
-      { 
+      {
         facet_counts: {
-          facet_pivot: { 
+          facet_pivot: {
             'field_a,field_b' => [
               {
-                field: 'field_a', 
-                value: 'a', 
-                count: 10, 
-                pivot: [{field: 'field_b', value: 'b', count: 2}]
-              }]
+                field: 'field_a',
+                value: 'a',
+                count: 10,
+                pivot: [{ field: 'field_b', value: 'b', count: 2 }]
+              }
+            ]
           }
         }
       }
     end
 
-    subject { Blacklight::Solr::Response.new(response, {}, blacklight_config: blacklight_config) }
-
-    it "should convert the pivot facet into a double RSolr FacetField" do
+    it "converts the pivot facet into a double RSolr FacetField" do
       field = subject.aggregations['my_pivot_facet_field']
 
       expect(field).to be_a_kind_of Blacklight::Solr::Response::Facets::FacetField
@@ -208,8 +209,7 @@ describe Blacklight::Solr::Response::Facets do
       expect(field.items.first).to respond_to(:items)
 
       expect(field.items.first.items.size).to eq 1
-      expect(field.items.first.items.first.fq).to eq({ 'field_a' => 'a' })
+      expect(field.items.first.items.first.fq).to eq('field_a' => 'a')
     end
   end
-
 end

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

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require "spec_helper"
 
-describe Blacklight::Solr::Response::GroupResponse do
-  
+RSpec.describe Blacklight::Solr::Response::GroupResponse, api: true do
   let(:response) do
     create_response(sample_response)
   end
@@ -12,7 +11,7 @@ describe Blacklight::Solr::Response::GroupResponse do
   end
 
   describe "groups" do
-    it "should return an array of Groups" do
+    it "returns an array of Groups" do
       expect(response.grouped).to be_a Array
 
       expect(group.groups).to have(2).items
@@ -20,8 +19,7 @@ describe Blacklight::Solr::Response::GroupResponse do
         expect(group).to be_a Blacklight::Solr::Response::Group
       end
     end
-    it "should include a list of SolrDocuments" do
-
+    it "includes a list of SolrDocuments" do
       group.groups.each do |group|
         group.docs.each do |doc|
           expect(doc).to be_a SolrDocument
@@ -29,9 +27,9 @@ describe Blacklight::Solr::Response::GroupResponse do
       end
     end
   end
-  
+
   describe "total" do
-    it "should return the ngroups value" do
+    it "returns the ngroups value" do
       expect(group.total).to eq 3
     end
   end
@@ -41,25 +39,25 @@ describe Blacklight::Solr::Response::GroupResponse do
       expect(group).to respond_to :aggregations
     end
   end
-  
+
   describe "rows" do
-    it "should get the rows from the response" do
+    it "gets the rows from the response" do
       expect(group.rows).to eq 3
     end
   end
 
   describe "group_field" do
-    it "should be the field name for the current group" do
+    it "is the field name for the current group" do
       expect(group.group_field).to eq "result_group_ssi"
     end
   end
 
   describe "group_limit" do
-    it "should be the number of documents to return for a group" do
+    it "is the number of documents to return for a group" do
       expect(group.group_limit).to eq 5
     end
   end
-  
+
   describe "empty?" do
     it "uses the total from this object" do
       expect(group.empty?).to be false
@@ -72,14 +70,10 @@ def create_response(response, params = {})
 end
 
 def sample_response
-  {"responseHeader" => {"params" =>{"rows" => 3, "group.limit" => 5}},
-   "grouped" => 
-     {'result_group_ssi' => 
-       {'groups' => [{'groupValue'=>"Group 1", 'doclist'=>{'numFound'=>2, 'docs'=>[{:id=>1}]}},
-                     {'groupValue'=>"Group 2", 'doclist'=>{'numFound'=>3, 'docs'=>[{:id=>2}, :id=>3]}}
-                    ],
-        'ngroups' => "3"
-       }
-     }
-  }
+  { "responseHeader" => { "params" => { "rows" => 3, "group.limit" => 5 } },
+    "grouped" =>
+     { 'result_group_ssi' =>
+       { 'groups' => [{ 'groupValue' => "Group 1", 'doclist' => { 'numFound' => 2, 'docs' => [{ id: 1 }] } },
+                      { 'groupValue' => "Group 2", 'doclist' => { 'numFound' => 3, 'docs' => [{ id: 2 }, id: 3] } }],
+         'ngroups' => "3" } } }
 end