blacklight 5.19.2 → 6.0.0.pre1

data/solr/sample_solr_documents.yml

@@ -2454,6 +2454,7 @@
   - Education India
   - Study and teaching India
   - Methodology
+  - Education Policy
   material_type_display:
   - xii, 419 p.
   subject_t:

data/spec/controllers/blacklight/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Blacklight::Base do
+  let(:controller) { (Class.new(ApplicationController) { include Blacklight::Base }).new }
+  subject { controller}
+
+  describe "#blacklight_path" do
+    let(:params) { double }
+    before { allow(controller).to receive_messages(params: params) }
+    subject { controller.send(:blacklight_path) }
+
+    it "creates a path object" do
+      expect(subject).to be_kind_of Blacklight::Path
+      expect(subject.params).to be params
+    end
+  end
+end

data/spec/controllers/blacklight/search_helper_spec.rb

@@ -11,8 +11,6 @@ require 'spec_helper'
 #
 describe Blacklight::SearchHelper do
 
-  let(:default_method_chain) { CatalogController.search_params_logic }
-
   # SearchHelper is a controller layer mixin, which depends
   # on being mixed into a class which has #params (from Rails)
   # and #blacklight_config
@@ -51,34 +49,6 @@ describe Blacklight::SearchHelper do
     @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
   end
 
-  describe "solr_search_params" do
-    it "allows customization of the filter pipeline" do
-      # Normally you'd include a new module into (eg) your CatalogController
-      # but a sub-class defininig it directly is simpler for test.
-      allow(subject).to receive(:add_foo_to_solr_params) do |solr_params, user_params|
-        solr_params[:wt] = "TESTING"
-      end
-
-      allow(Deprecation).to receive(:warn)
-      expect(subject.solr_search_params({}, [:add_foo_to_solr_params])[:wt]).to eq "TESTING"
-    end
-  end
-
-  describe "get_facet_pagination", :integration => true do
-    before do
-      @facet_field = 'format'
-      Deprecation.silence(Blacklight::SearchHelper) do
-        @facet_paginator = subject.get_facet_pagination(@facet_field)
-      end
-    end
-    it 'should return a facet paginator' do
-      expect(@facet_paginator).to be_a_kind_of(Blacklight::Solr::FacetPaginator)
-    end
-    it 'with a limit set' do
-      expect(@facet_paginator.limit).not_to be_nil
-    end
-  end
-
   # SPECS FOR SEARCH RESULTS FOR QUERY
   describe 'Search Results', :integration => true do
 
@@ -86,7 +56,7 @@ describe Blacklight::SearchHelper do
     describe 'for a sample query returning results' do
 
       before do
-        (@solr_response, @document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
+        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
       end
 
       it "should use the configured request handler " do
@@ -97,7 +67,7 @@ describe Blacklight::SearchHelper do
           expect(params[:params]["facet.query"]).to eq ["pub_date:[#{5.years.ago.year} TO *]", "pub_date:[#{10.years.ago.year} TO *]", "pub_date:[#{25.years.ago.year} TO *]"]
           expect(params[:params]).to include('rows' => 10, 'qt'=>"custom_request_handler", 'q'=>"", "f.subject_topic_facet.facet.limit"=>21, 'sort'=>"score desc, pub_date_sort desc, title_sort asc")
         end.and_return({'response'=>{'docs'=>[]}})
-        subject.search_results({ q: @all_docs_query }, default_method_chain)
+        subject.search_results(q: @all_docs_query)
       end
 
       it 'should have a @response.docs list of the same size as @document_list' do
@@ -118,44 +88,12 @@ describe Blacklight::SearchHelper do
       end
     end
 
-    describe "with SearchBuilder replacement block" do
-      it "should pass configured SearchBuilder and use returned SearchBuilder" do
-        replacement_search_builder = subject.search_builder([:new_chain])
-
-        # Sorry, have to use mocks to make sure method really passes the
-        # block return value to the repository search, couldn't figure
-        # out a better way to test. 
-        expect(subject.repository).to receive(:search) do |arg_search_builder|
-          expect(arg_search_builder).to equal(replacement_search_builder)
-        end.and_return(
-          blacklight_config.response_model.new({'response'=>{'docs'=>[]}}, {}, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
-        )
-
-        subject.search_results({q: @no_docs_query}, [:one, :two]) do |arg_search_builder|
-          expect(arg_search_builder.processor_chain).to eq([:one, :two])
-
-          replacement_search_builder
-        end
-      end
-    end
-
-    describe "#get_search_results " do
-      it "should be deprecated and return results" do
-        expect(Deprecation).to receive(:warn)
-        (solr_response, document_list) = subject.get_search_results(q: @all_docs_query)
-        result_docs = document_list
-        document = result_docs.first
-        expect(document.fetch(blacklight_config.index.title_field)).not_to be_nil
-        expect(document.fetch(blacklight_config.index.display_type_field)).not_to be_nil
-      end
-    end
-
     describe "for a query returning a grouped response" do
       let(:blacklight_config) { copy_of_catalog_config }
       before do
         blacklight_config.default_solr_params[:group] = true
         blacklight_config.default_solr_params[:'group.field'] = 'pub_date_sort'
-        (@solr_response, @document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
+        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
       end
 
       it "should have an empty document list" do
@@ -175,7 +113,7 @@ describe Blacklight::SearchHelper do
         allow(subject).to receive_messages grouped_key_for_results: 'title_sort'
         blacklight_config.default_solr_params[:group] = true
         blacklight_config.default_solr_params[:'group.field'] = ['pub_date_sort', 'title_sort']
-        (@solr_response, @document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
+        (@solr_response, @document_list) = subject.search_results(q: @all_docs_query)
       end
 
       it "should have an empty document list" do
@@ -188,85 +126,10 @@ describe Blacklight::SearchHelper do
       end
     end
 
-    describe '#query_solr' do
-      it 'should have results' do
-        expect(Deprecation).to receive(:warn)
-        solr_response = subject.query_solr(q: @single_word_query)
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-
-    end
-
-    describe 'for All Docs Query, No Facets' do
-      it 'should have non-nil values for required doc fields set in initializer' do
-        (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
-        result_docs = document_list
-        document = result_docs.first
-        expect(document.fetch(blacklight_config.index.title_field)).not_to be_nil
-        expect(document.fetch(blacklight_config.index.display_type_field)).not_to be_nil
-      end
-    end
-
-
-
-    describe "Single Word Query with no Facets" do
-      it 'should have results' do
-        expect(Deprecation).to receive(:warn)
-        solr_response = subject.query_solr( q: @single_word_query)
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-
-      it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ q: @single_word_query }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
-
-    describe "Multiple Words Query with No Facets" do
-      it 'should have results' do
-
-        (solr_response, document_list) = subject.search_results({ q: @mult_word_query }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
-
-    describe "One Facet, No Query" do
-      it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ f: @single_facet }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
-
-    describe "Mult Facets, No Query" do
-      it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ f: @multi_facets }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
-
-    describe "Single Word Query with One Facet" do
-      it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ q: @single_word_query, f: @single_facet }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
-
-    describe "Multiple Words Query with Multiple Facets" do
-      it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ q: @mult_word_query, f: @multi_facets }, default_method_chain)
-        expect(solr_response.docs).to have(document_list.size).results
-        expect(solr_response.docs).to have_at_least(1).result
-      end
-    end
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
-        (solr_response, document_list) = subject.search_results({ q: @all_docs_query, f: @single_facet }, default_method_chain)
+        (solr_response, document_list) = subject.search_results(q: @all_docs_query, f: @single_facet)
         expect(solr_response.docs).to have(document_list.size).results
         expect(solr_response.docs).to have_at_least(1).result
       end
@@ -276,7 +139,7 @@ describe Blacklight::SearchHelper do
 
     describe "for Query Without Results and No Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.search_results({ q: @no_docs_query }, default_method_chain)
+        (solr_response, document_list) = subject.search_results(q: @no_docs_query)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
@@ -284,7 +147,7 @@ describe Blacklight::SearchHelper do
 
     describe "for Query Without Results and One Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.search_results({ q: @no_docs_query, f: @single_facet }, default_method_chain)
+        (solr_response, document_list) = subject.search_results(q: @no_docs_query, f: @single_facet)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
@@ -292,7 +155,7 @@ describe Blacklight::SearchHelper do
 
     describe "for All Docs Query and Bad Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.search_results({ q: @all_docs_query, f: @bad_facet }, default_method_chain)
+        (solr_response, document_list) = subject.search_results(q: @all_docs_query, f: @bad_facet)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
@@ -306,7 +169,7 @@ describe Blacklight::SearchHelper do
     let(:blacklight_config) { copy_of_catalog_config }
 
     before do
-      (solr_response, document_list) = subject.search_results({ q: @all_docs_query}, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
       @facets = solr_response.aggregations
     end
 
@@ -348,44 +211,44 @@ describe Blacklight::SearchHelper do
     let(:blacklight_config) { copy_of_catalog_config }
 
     it 'should start with first results by default' do
-      (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
       expect(solr_response.params[:start].to_i).to eq 0
     end
     it 'should have number of results (per page) set in initializer, by default' do
-      (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: @all_docs_query)
       expect(solr_response.docs).to have(blacklight_config[:default_solr_params][:rows]).items
       expect(document_list).to have(blacklight_config[:default_solr_params][:rows]).items
     end
 
     it 'should get number of results per page requested' do
       num_results = 3  # non-default value
-      (solr_response1, document_list1) = subject.search_results({ q: @all_docs_query, per_page: num_results }, default_method_chain)
+      (solr_response1, document_list1) = subject.search_results(q: @all_docs_query, per_page: num_results)
       expect(document_list1).to have(num_results).docs
       expect(solr_response1.docs).to have(num_results).docs
     end
 
     it 'should get number of rows requested' do
       num_results = 4  # non-default value
-      (solr_response1, document_list1) = subject.search_results({ q: @all_docs_query, rows: num_results }, default_method_chain)
+      (solr_response1, document_list1) = subject.search_results(q: @all_docs_query, rows: num_results)
       expect(document_list1).to have(num_results).docs
       expect(solr_response1.docs).to have(num_results).docs
     end
 
     it 'should skip appropriate number of results when requested - default per page' do
       page = 3
-      (solr_response2, document_list2) = subject.search_results({ q: @all_docs_query, page: page }, default_method_chain)
+      (solr_response2, document_list2) = subject.search_results(q: @all_docs_query, page: page)
       expect(solr_response2.params[:start].to_i).to eq  blacklight_config[:default_solr_params][:rows] * (page-1)
     end
     it 'should skip appropriate number of results when requested - non-default per page' do
       page = 3
       num_results = 3
-      (solr_response2a, document_list2a) = subject.search_results({ q: @all_docs_query, per_page: num_results, page: page }, default_method_chain)
+      (solr_response2a, document_list2a) = subject.search_results(q: @all_docs_query, per_page: num_results, page: page)
       expect(solr_response2a.params[:start].to_i).to eq num_results * (page-1)
     end
 
     it 'should have no results when prompted for page after last result' do
       big = 5000
-      (solr_response3, document_list3) = subject.search_results({ q: @all_docs_query, rows: big, page: big },  default_method_chain)
+      (solr_response3, document_list3) = subject.search_results(q: @all_docs_query, rows: big, page: big)
       expect(document_list3).to have(0).docs
       expect(solr_response3.docs).to have(0).docs
     end
@@ -393,12 +256,12 @@ describe Blacklight::SearchHelper do
     it 'should show first results when prompted for page before first result' do
       # FIXME: should it show first results, or should it throw an error for view to deal w?
       #   Solr throws an error for a negative start value
-      (solr_response4, document_list4) = subject.search_results({ q: @all_docs_query, page: '-1' }, default_method_chain)
+      (solr_response4, document_list4) = subject.search_results(q: @all_docs_query, page: '-1')
       expect(solr_response4.params[:start].to_i).to eq 0
     end
     it 'should have results available when asked for more than are in response' do
       big = 5000
-      (solr_response5, document_list5) = subject.search_results({ q: @all_docs_query, rows: big, page: 1 }, default_method_chain)
+      (solr_response5, document_list5) = subject.search_results(q: @all_docs_query, rows: big, page: 1)
       expect(solr_response5.docs).to have(document_list5.length).docs
       expect(solr_response5.docs).to have_at_least(1).doc
     end
@@ -407,16 +270,6 @@ describe Blacklight::SearchHelper do
 
   # SPECS FOR SINGLE DOCUMENT REQUESTS
   describe 'Get Document By Id', :integration => true do
-
-    describe "#get_solr_response_for_doc_id" do
-      let(:doc_id) { '2007020969' }
-      it "should be deprecated" do
-        expect(Deprecation).to receive(:warn).at_least(1).times
-        expect(subject.repository).to receive(:find).with(@doc_id, {}).and_call_original
-        subject.get_solr_response_for_doc_id(@doc_id)
-      end
-    end
-
     before do
       @doc_id = '2007020969'
       @bad_id = "redrum"
@@ -455,113 +308,16 @@ describe Blacklight::SearchHelper do
     end
   end
 
-  describe "solr_doc_params" do
-    it "should default to using the 'document' requestHandler" do
-      Deprecation.silence(Blacklight::SearchHelper) do
-        doc_params = subject.solr_doc_params('asdfg')
-        expect(doc_params[:qt]).to eq 'document'
-      end
-    end
-
-    it "should default to using the id parameter when sending solr queries" do
-      Deprecation.silence(Blacklight::SearchHelper) do
-        doc_params = subject.solr_doc_params('asdfg')
-        expect(doc_params[:id]).to eq 'asdfg'
-      end
-    end
-
-    it "should use the document_unique_id_param configuration" do
-      Deprecation.silence(Blacklight::SearchHelper) do
-        allow(blacklight_config).to receive_messages(document_unique_id_param: :ids)
-        doc_params = subject.solr_doc_params('asdfg')
-        expect(doc_params[:ids]).to eq 'asdfg'
-      end
-    end
-
-    describe "blacklight config's default_document_solr_parameters" do
-      it "should use parameters from the controller's default_document_solr_parameters" do
-        Deprecation.silence(Blacklight::SearchHelper) do
-          blacklight_config.default_document_solr_params = { :qt => 'my_custom_handler', :asdf => '1234' }
-          doc_params = subject.solr_doc_params('asdfg')
-          expect(doc_params[:qt]).to eq 'my_custom_handler'
-          expect(doc_params[:asdf]).to eq '1234'
-        end
-      end
-    end
-
-  end
-
-  describe "Get Document by custom unique id" do
-=begin    
-    # Can't test this properly without updating the "document" request handler in solr
-    it "should respect the configuration-supplied unique id" do
-      allow(SolrDocument).to receive(:unique_key).and_return("title_display")
-      @response, @document = @solr_helper.fetch('"Strong Medicine speaks"')
-      @document.id).to eq '"Strong Medicine speaks"'
-      @document.get(:id)).to eq 2007020969
-    end
-=end
-    it "should respect the configuration-supplied unique id" do
-      Deprecation.silence(Blacklight::SearchHelper) do
-        doc_params = subject.solr_doc_params('"Strong Medicine speaks"')
-        expect(doc_params[:id]).to eq '"Strong Medicine speaks"'
-      end
-    end
-  end
-
-
-
-# SPECS FOR SINGLE DOCUMENT VIA SEARCH
-  describe "Get Document Via Search", :integration => true do
-    before do
-      @doc_row = 3
-      Deprecation.silence(Blacklight::SearchHelper) do
-        @doc = subject.get_single_doc_via_search(@doc_row, :q => @all_docs_query)
-      end
-    end
-=begin
-# can't test these here, because the method only returns the document
-    it "should get a single document" do
-      response.docs.size).to eq 1
-    end
-
-    doc2 = get_single_doc_via_search(@all_docs_query, nil, @doc_row, @multi_facets)
-    it "should limit search result by facets when supplied" do
-      response2expect(.docs.numFound).to_be < response.docs.numFound
-    end
-
-    it "should not have facets in the response" do
-      response.facets.size).to eq 0
-    end
-=end
-
-    it 'should have a doc id field' do
-      expect(@doc[:id]).not_to be_nil
-    end
-
-    it 'should have non-nil values for required fields set in initializer' do
-      expect(@doc[blacklight_config.view_config(:show).display_type_field]).not_to be_nil
-    end
-
-    it "should limit search result by facets when supplied" do
-      Deprecation.silence(Blacklight::SearchHelper) do
-        doc2 = subject.get_single_doc_via_search(@doc_row , :q => @all_docs_query, :f => @multi_facets)
-        expect(doc2[:id]).not_to be_nil
-      end
-    end
-
-  end
-
 # SPECS FOR SPELLING SUGGESTIONS VIA SEARCH
   describe "Searches should return spelling suggestions", :integration => true do
     it 'search results for just-poor-enough-query term should have (multiple) spelling suggestions' do
-      (solr_response, document_list) = subject.search_results({ q: 'boo' }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: 'boo')
       expect(solr_response.spelling.words).to include('bon')
       expect(solr_response.spelling.words).to include('bod')  #for multiple suggestions
     end
 
     it 'search results for just-poor-enough-query term should have multiple spelling suggestions' do
-      (solr_response, document_list) = subject.search_results({ q: 'politica' }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: 'politica')
       expect(solr_response.spelling.words).to include('policy') # less freq
       expect(solr_response.spelling.words).to include('politics') # more freq
       expect(solr_response.spelling.words).to include('political') # more freq
@@ -574,17 +330,17 @@ describe Blacklight::SearchHelper do
     end
 
     it "title search results for just-poor-enough query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results({ q: 'yehudiyam', qt: 'search', :"spellcheck.dictionary" => "title" }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: 'yehudiyam', qt: 'search', :"spellcheck.dictionary" => "title")
       expect(solr_response.spelling.words).to include('yehudiyim')
     end
 
     it "author search results for just-poor-enough-query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results({ q: 'shirma', qt: 'search', :"spellcheck.dictionary" => "author" }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: 'shirma', qt: 'search', :"spellcheck.dictionary" => "author")
       expect(solr_response.spelling.words).to include('sharma')
     end
 
     it "subject search results for just-poor-enough-query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.search_results({ q: 'wome', qt: 'search', :"spellcheck.dictionary" => "subject" }, default_method_chain)
+      (solr_response, document_list) = subject.search_results(q: 'wome', qt: 'search', :"spellcheck.dictionary" => "subject")
       expect(solr_response.spelling.words).to include('women')
     end
 
@@ -641,33 +397,6 @@ describe Blacklight::SearchHelper do
     end
   end
 
-    describe "#get_solr_response_for_field_values" do
-      before do
-        @mock_response = double()
-        allow(@mock_response).to receive_messages(documents: [])
-      end
-      it "should contruct a solr query based on the field and value pair" do
-        Deprecation.silence(Blacklight::SearchHelper) do
-          allow(subject.repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(value)")).and_return(@mock_response)
-          subject.get_solr_response_for_field_values('field_name', 'value')
-        end
-      end
-
-      it "should OR multiple values together" do
-        Deprecation.silence(Blacklight::SearchHelper) do
-          allow(subject.repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(a OR b)")).and_return(@mock_response)
-          subject.get_solr_response_for_field_values('field_name', ['a', 'b'])
-        end
-      end
-
-      it "should escape crazy identifiers" do
-        Deprecation.silence(Blacklight::SearchHelper) do
-          allow(subject.repository).to receive(:send_and_receive).with('select', hash_including("q" => "{!lucene}field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
-          subject.get_solr_response_for_field_values('field_name', 'h://"\'')
-        end
-      end
-    end
-
 # TODO:  more complex queries!  phrases, offset into search results, non-latin, boosting(?)
 #  search within query building (?)
 #  search + facets (search done first; facet selected first, both selected)
@@ -677,8 +406,7 @@ describe Blacklight::SearchHelper do
 #  nearby on shelf
   it "should raise 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(Deprecation).to receive(:warn)
-    expect { subject.query_solr }.to raise_exception(/Unable to connect to Solr instance/)
+    expect { subject.repository.search }.to raise_exception(/Unable to connect to Solr instance/)
   end
 
   describe "grouped_key_for_results" do
@@ -691,7 +419,7 @@ describe Blacklight::SearchHelper do
   describe "#get_previous_and_next_documents_for_search" do
     let(:pre_query) { SearchHelperTestClass.new blacklight_config, blacklight_solr }
     before do
-      @full_response, @all_docs = pre_query.search_results({ q: '', per_page: '100' }, default_method_chain)
+      @full_response, @all_docs = pre_query.search_results(q: '', per_page: '100')
     end
 
     it "should return the previous and next documents for a search" do