From fd2095163f0c415429b60468490f9bddf50f933f Mon Sep 17 00:00:00 2001
From: Justin Coyne <justin@curationexperts.com>
Date: Tue, 3 Feb 2015 13:57:53 -0600
Subject: [PATCH] Rename get_search_results to search_results `search_results`
 lets you pass in the filter methods.  This is helpful for when you have
 different methods in the same class (e.g. index, show) both calling
 `search_results`, but with different filters to run.

---
 lib/blacklight/catalog.rb                     |   2 +-
 lib/blacklight/request_builders.rb            |  14 +-
 lib/blacklight/solr_helper.rb                 |  45 +++-
 spec/controllers/catalog_controller_spec.rb   |   4 +-
 spec/lib/blacklight/solr_helper_spec.rb       | 250 +++++++++---------
 .../catalog/_constraints.html.erb_spec.rb     |   2 +-
 .../_paginate_compact.html.erb_spec.rb        |   2 +-
 spec/views/catalog/index.atom.builder_spec.rb |   2 +-
 8 files changed, 174 insertions(+), 147 deletions(-)

diff --git a/lib/blacklight/catalog.rb b/lib/blacklight/catalog.rb
index cdb8b6d334..6a1353bd87 100644
--- a/lib/blacklight/catalog.rb
+++ b/lib/blacklight/catalog.rb
@@ -30,7 +30,7 @@ module Blacklight::Catalog
 
     # get search results from the solr index
     def index
-      (@response, @document_list) = get_search_results
+      (@response, @document_list) = search_results(params, {}, solr_search_params_logic)
 
       respond_to do |format|
         format.html { preferred_view }
diff --git a/lib/blacklight/request_builders.rb b/lib/blacklight/request_builders.rb
index 6961da22e9..9bee6a4027 100644
--- a/lib/blacklight/request_builders.rb
+++ b/lib/blacklight/request_builders.rb
@@ -45,14 +45,22 @@ module RequestBuilders
     # specified otherwise. 
     #
     # Incoming parameter :f is mapped to :fq solr parameter.
-    def solr_search_params(user_params = params || {})
+    def solr_search_params(user_params = nil, processor_chain = nil)
+      unless user_params
+        Deprecation.warn(RequestBuilders, "Calling solr_search_params without a `user_params' argument is deprecated and will be removed in blacklight-6.0")
+        user_params = params || {}
+      end
+      unless processor_chain
+        Deprecation.warn(RequestBuilders, "Calling solr_search_params without a `processor_chain' argument is deprecated and will be removed in blacklight-6.0")
+        processor_chain = solr_search_params_logic
+      end
       Blacklight::Solr::Request.new.tap do |solr_parameters|
-        solr_search_params_logic.each do |method_name|
+        processor_chain.each do |method_name|
           send(method_name, solr_parameters, user_params)
         end
       end
     end
-    
+
     ##
     # Retrieve the results for a list of document ids
     def solr_document_ids_params(ids = [])
diff --git a/lib/blacklight/solr_helper.rb b/lib/blacklight/solr_helper.rb
index 8c4cd6c944..2deccace28 100644
--- a/lib/blacklight/solr_helper.rb
+++ b/lib/blacklight/solr_helper.rb
@@ -78,7 +78,17 @@ def solr_doc_params(id=nil)
   # Returns a two-element array (aka duple) with first the solr response object,
   # and second an array of SolrDocuments representing the response.docs
   def get_search_results(user_params = params || {}, extra_controller_params = {})
-    solr_response = query_solr(user_params, extra_controller_params)
+    Deprecation.warn(self, "get_search_results is deprecated and will be removed in blacklight-6.0. Use `search_results' instead")
+    search_results(user_params, extra_controller_params, solr_search_params_logic)
+  end
+
+  # a solr query method
+  # @param [Hash,HashWithIndifferentAccess] user_params ({}) the user provided parameters (e.g. query, facets, sort, etc)
+  # @param [Hash,HashWithIndifferentAccess] extra_controller_params ({}) extra parameters to add to the search
+  # @param [List<Symbol] processor_chain a list of filter methods to run
+  # @return [Blacklight::SolrResponse] the solr response object
+  def search_results(user_params, extra_controller_params, solr_search_parms_logic)
+    solr_response = query_solr(user_params, extra_controller_params, solr_search_params_logic)
 
     case
     when (solr_response.grouped? && grouped_key_for_results)
@@ -90,12 +100,25 @@ def get_search_results(user_params = params || {}, extra_controller_params = {})
     end
   end
 
-  	
   # a solr query method
-  # given a user query,
+  # @param [Hash,HashWithIndifferentAccess] user_params ({}) the user provided parameters (e.g. query, facets, sort, etc)
+  # @param [Hash,HashWithIndifferentAccess] extra_controller_params ({}) extra parameters to add to the search
+  # @param [List<Symbol] processor_chain a list of filter methods to run
   # @return [Blacklight::SolrResponse] the solr response object
-  def query_solr(user_params = params || {}, extra_controller_params = {})
-    solr_params = self.solr_search_params(user_params).merge(extra_controller_params)
+  def query_solr(user_params = nil, extra_controller_params = nil, processor_chain = nil)
+      unless user_params
+        Deprecation.warn(self, "Calling query_solr without a `user_params' argument is deprecated and will be removed in blacklight-6.0")
+        user_params = params || {}
+      end
+      unless extra_controller_params
+        Deprecation.warn(self, "Calling query_solr without a `extra_controller_params' argument is deprecated and will be removed in blacklight-6.0")
+        extra_controller_params = {}
+      end
+      unless processor_chain
+        Deprecation.warn(self, "Calling query_solr without a `processor_chain' argument is deprecated and will be removed in blacklight-6.0")
+        processor_chain = solr_search_params_logic
+      end
+    solr_params = solr_search_params(user_params, processor_chain).merge(extra_controller_params)
 
     solr_repository.search(solr_params)
   end
@@ -137,7 +160,7 @@ def get_solr_response_for_document_ids(ids=[], *args)
       extra_controller_params ||= {}
     end
 
-    solr_response = query_solr(user_params, extra_controller_params.merge(solr_document_ids_params(ids)))
+    solr_response = query_solr(user_params, extra_controller_params.merge(solr_document_ids_params(ids)), solr_search_params_logic)
 
     [solr_response, solr_response.documents]
   end
@@ -145,7 +168,7 @@ def get_solr_response_for_document_ids(ids=[], *args)
   # given a field name and array of values, get the matching SOLR documents
   # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response object and a list of solr documents
   def get_solr_response_for_field_values(field, values, extra_controller_params = {})
-    solr_response = query_solr(params, extra_controller_params.merge(solr_documents_by_field_values_params(field, values)))
+    solr_response = query_solr(params, extra_controller_params.merge(solr_documents_by_field_values_params(field, values)), solr_search_params_logic)
 
     [solr_response, solr_response.documents]
   end
@@ -156,7 +179,7 @@ def get_solr_response_for_field_values(field, values, extra_controller_params =
   # @return [Blacklight::SolrResponse] the solr response
   def get_facet_field_response(facet_field, user_params = params || {}, extra_controller_params = {})
     solr_params = solr_facet_params(facet_field, user_params, extra_controller_params)
-    query_solr(user_params, extra_controller_params.merge(solr_facet_params(facet_field, user_params, extra_controller_params)))
+    query_solr(user_params, extra_controller_params.merge(solr_facet_params(facet_field, user_params, extra_controller_params)), solr_search_params_logic)
   end
 
   # a solr query method
@@ -187,7 +210,7 @@ def get_facet_pagination(facet_field, user_params=params || {}, extra_controller
   # the Blacklight app-level request params that define the search.
   # @return [Blacklight::SolrDocument, nil] the found document or nil if not found
   def get_single_doc_via_search(index, request_params)
-    solr_params = solr_search_params(request_params)
+    solr_params = solr_search_params(request_params, solr_search_params_logic)
 
     solr_params[:start] = (index - 1) # start at 0 to get 1st doc, 1 to get 2nd.
     solr_params[:rows] = 1
@@ -201,7 +224,7 @@ def get_single_doc_via_search(index, request_params)
   # @return [Blacklight::SolrResponse, Array<Blacklight::SolrDocument>] the solr response and a list of the first and last document
   def get_previous_and_next_documents_for_search(index, request_params, extra_controller_params={})
 
-    solr_response = query_solr(request_params, extra_controller_params.merge(previous_and_next_document_params(index)))
+    solr_response = query_solr(request_params, extra_controller_params.merge(previous_and_next_document_params(index)), solr_search_params_logic)
 
     document_list = solr_response.documents
 
@@ -221,7 +244,7 @@ def get_previous_and_next_documents_for_search(index, request_params, extra_cont
   def get_opensearch_response(field=nil, request_params = params || {}, extra_controller_params={})
     field ||= blacklight_config.view_config('opensearch').title_field
 
-    response = query_solr(request_params, solr_opensearch_params(field).merge(extra_controller_params))
+    response = query_solr(request_params, solr_opensearch_params(field).merge(extra_controller_params), solr_search_params_logic)
 
     [response.params[:q], response.documents.flat_map {|doc| doc[field] }.uniq]
   end
diff --git a/spec/controllers/catalog_controller_spec.rb b/spec/controllers/catalog_controller_spec.rb
index aedef97ea2..c242519128 100644
--- a/spec/controllers/catalog_controller_spec.rb
+++ b/spec/controllers/catalog_controller_spec.rb
@@ -520,9 +520,9 @@ def export_as_mock
     it "should redirect the user to the root url for a bad search" do
       req = {}
       res = {}
-      fake_error = RSolr::Error::Http.new(req, res) 
+      fake_error = RSolr::Error::Http.new(req, res)
       allow(Rails.env).to receive_messages(:test? => false)
-      allow(controller).to receive(:get_search_results) { |*args| raise fake_error }
+      allow(controller).to receive(:search_results) { |*args| raise fake_error }
       expect(controller.logger).to receive(:error).with(fake_error)
       get :index, :q=>"+"
 
diff --git a/spec/lib/blacklight/solr_helper_spec.rb b/spec/lib/blacklight/solr_helper_spec.rb
index beb7720528..990e76a0c1 100644
--- a/spec/lib/blacklight/solr_helper_spec.rb
+++ b/spec/lib/blacklight/solr_helper_spec.rb
@@ -11,6 +11,8 @@
 #
 describe Blacklight::SolrHelper do
 
+  let(:default_method_chain) { CatalogController.solr_search_params_logic }
+
   # SolrHelper is a controller layer mixin, which depends
   # on being mixed into a class which has #params (from Rails)
   # and #blacklight_config
@@ -53,20 +55,18 @@ def params
   describe "solr_search_params" do
     it "allows customization of solr_search_params_logic" do
         # Normally you'd include a new module into (eg) your CatalogController
-        # but a sub-class defininig it directly is simpler for test.             
+        # 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
-                         
-        subject.solr_search_params_logic += [:add_foo_to_solr_params]
-                
-        expect(subject.solr_search_params[:wt]).to eq "TESTING"                
+
+        expect(subject.solr_search_params({}, [:add_foo_to_solr_params])[:wt]).to eq "TESTING"
     end
     
     
     describe 'for an entirely empty search' do
       before do
-        @produced_params = subject.solr_search_params.with_indifferent_access
+        @produced_params = subject.solr_search_params({}, default_method_chain).with_indifferent_access
       end
 
       let(:blacklight_config) { copy_of_catalog_config }
@@ -95,15 +95,15 @@ def params
 
     describe "for an empty string search" do      
       it "should return empty string q in solr parameters" do        
-        solr_params = subject.solr_search_params(:q => "")
+        solr_params = subject.solr_search_params({ q: "" }, default_method_chain)
         expect(solr_params[:q]).to eq ""
         expect(solr_params["spellcheck.q"]).to eq ""
       end
     end
 
-    describe "for request params also passed in as argument" do      
-      it "should only have one value for the key 'q' regardless if a symbol or string" do        
-        solr_params = subject.solr_search_params( :q => "some query", 'q' => 'another value' )
+    describe "for request params also passed in as argument" do
+      it "should only have one value for the key 'q' regardless if a symbol or string" do
+        solr_params = subject.solr_search_params({ q: "some query", 'q' => 'another value' }, default_method_chain)
         expect(solr_params[:q]).to eq 'some query'
         expect(solr_params['q']).to eq 'some query'
       end
@@ -113,7 +113,7 @@ def params
     describe "for one facet, no query" do
       it "should have proper solr parameters" do
 
-        solr_params = subject.solr_search_params(:f => @single_facet)
+        solr_params = subject.solr_search_params({ f: @single_facet }, default_method_chain)
 
         expect(solr_params[:q]).to be_blank
         expect(solr_params["spellcheck.q"]).to be_blank
@@ -126,7 +126,7 @@ def params
 
     describe "for an empty facet limit param" do
       it "should not add any fq to solr" do
-        solr_params = subject.solr_search_params(:f => {"format" => [""]})
+        solr_params = subject.solr_search_params({ f: { "format" => [""] } }, default_method_chain)
 
         expect(solr_params[:fq]).to be_blank
       end
@@ -134,7 +134,7 @@ def params
 
     describe "with Multi Facets, No Query" do
       it 'should have fq set properly' do
-        solr_params = subject.solr_search_params(:f => @multi_facets)
+        solr_params = subject.solr_search_params({ f: @multi_facets }, default_method_chain)
 
         @multi_facets.each_pair do |facet_field, value_list|
           value_list ||= []
@@ -149,7 +149,7 @@ def params
 
     describe "with Multi Facets, Multi Word Query" do
       it 'should have fq and q set properly' do
-        solr_params = subject.solr_search_params(:q => @mult_word_query, :f => @multi_facets)
+        solr_params = subject.solr_search_params({ q: @mult_word_query, f: @multi_facets }, default_method_chain)
 
         @multi_facets.each_pair do |facet_field, value_list|
           value_list ||= []
@@ -227,7 +227,7 @@ def params
     end
 
     describe "solr parameters for a field search from config (subject)" do
-      let(:solr_params) { subject.solr_search_params @subject_search_params }
+      let(:solr_params) { subject.solr_search_params @subject_search_params, default_method_chain }
       let(:blacklight_config) { copy_of_catalog_config }
 
       it "should look up qt from field definition" do
@@ -258,11 +258,9 @@ def params
         expect(solr_params[:"spellcheck.dictionary"]).to eq "subject"
       end
       it "should add on :solr_local_parameters using Solr LocalParams style" do
-        params = subject.solr_search_params( @subject_search_params )
-
         #q == "{!pf=$subject_pf $qf=subject_qf} wome", make sure
         #the LocalParams are really there
-        params[:q] =~ /^\{!([^}]+)\}/
+        solr_params[:q] =~ /^\{!([^}]+)\}/
         key_value_pairs = $1.split(" ")
         expect(key_value_pairs).to include("pf=$subject_pf")
         expect(key_value_pairs).to include("qf=$subject_qf")
@@ -270,17 +268,21 @@ def params
     end
 
     describe "overriding of qt parameter" do
+      let(:user_params) do
+        { qt: 'overridden' }
+      end
+      let(:produced_params) { subject.solr_search_params(user_params, default_method_chain) }
+
       it "should return the correct overriden parameter" do
         allow(subject).to receive_messages(params: { qt: 'overridden' })
-        
-        expect(subject.solr_search_params[:qt]).to eq "overridden"        
+        expect(produced_params[:qt]).to eq "overridden"
       end
     end
 
     describe "converts a String fq into an Array" do
       it "should return the correct overriden parameter" do
         solr_parameters = {:fq => 'a string' }
-        
+
         subject.add_facet_fq_to_solr(solr_parameters, {})
 
         expect(solr_parameters[:fq]).to be_a_kind_of Array
@@ -430,66 +432,60 @@ def params
         return config
       end
 
-      before do
-        allow(subject).to receive_messages params: {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
+      let(:user_params) do
+        {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
       end
-      
+
+      let(:produced_params) { subject.solr_search_params(user_params, default_method_chain) }
+
       it "should merge parameters from search_field definition" do
-        solr_params = subject.solr_search_params
-        
-        expect(solr_params[:qf]).to eq "fieldOne^2.3 fieldTwo fieldThree^0.4"
-        expect(solr_params[:spellcheck]).to eq 'false'
+        expect(produced_params[:qf]).to eq "fieldOne^2.3 fieldTwo fieldThree^0.4"
+        expect(produced_params[:spellcheck]).to eq 'false'
       end
       it "should merge empty string parameters from search_field definition" do
-        expect(subject.solr_search_params[:pf]).to eq ""        
+        expect(produced_params[:pf]).to eq ""
       end
 
       describe "should respect proper precedence of settings, " do
-        before do
-          @produced_params = subject.solr_search_params
-        end
-
-
         it "should not put :search_field in produced params" do
-          expect(@produced_params[:search_field]).to be_nil
+          expect(produced_params[:search_field]).to be_nil
         end
 
         it "should fall through to BL general defaults for qt not otherwise specified " do
-          expect(@produced_params[:qt]).to eq blacklight_config[:default_solr_params][:qt]
+          expect(produced_params[:qt]).to eq blacklight_config[:default_solr_params][:qt]
         end
 
         it "should take rows from search field definition where specified" do
-          expect(@produced_params[:rows]).to eq "55"
+          expect(produced_params[:rows]).to eq "55"
         end
 
         it "should take q from request params" do
-          expect(@produced_params[:q]).to eq "test query"
+          expect(produced_params[:q]).to eq "test query"
         end
 
         it "should add in extra facet.field from params" do
-          expect(@produced_params[:"facet.field"]).to include("extra_facet")
+          expect(produced_params[:"facet.field"]).to include("extra_facet")
         end
-
       end
     end
 
     describe "sorting" do
       let(:blacklight_config) { copy_of_catalog_config }
-      
-      it "should send the default sort parameter to solr" do                        
-        expect(subject.solr_search_params[:sort]).to eq 'score desc, pub_date_sort desc, title_sort asc'        
+
+      it "should send the default sort parameter to solr" do
+        expect(subject.solr_search_params({}, default_method_chain)[:sort]).to eq 'score desc, pub_date_sort desc, title_sort asc'
       end
 
       it "should not send a sort parameter to solr if the sort value is blank" do
         blacklight_config.sort_fields = {}
         blacklight_config.add_sort_field('', :label => 'test')
 
-        produced_params = subject.solr_search_params
+        produced_params = subject.solr_search_params({}, default_method_chain)
         expect(produced_params).not_to have_key(:sort)
       end
 
       it "should pass through user sort parameters" do
-        produced_params = subject.solr_search_params( :sort => 'solr_test_field desc' )
+        produced_params = subject.solr_search_params({ sort: 'solr_test_field desc' }, default_method_chain)
         expect(produced_params[:sort]).to eq 'solr_test_field desc'
       end
     end
@@ -514,28 +510,24 @@ def params
         )
         return config
       end
-      
-      before do        
-        allow(subject).to receive_messages params: {:search_field => "custom_author_key", :q => "query"}
-      end
-      
-      before do
-        @result = subject.solr_search_params
+
+      let(:result) do
+        subject.solr_search_params({:search_field => "custom_author_key", :q => "query"}, default_method_chain)
       end
 
       it "should pass through ordinary params" do
-        expect(@result[:qt]).to eq "author_qt"
-        expect(@result[:ps]).to eq "2"
-        expect(@result[:qf]).to eq "someField^1000"
+        expect(result[:qt]).to eq "author_qt"
+        expect(result[:ps]).to eq "2"
+        expect(result[:qf]).to eq "someField^1000"
       end
 
       it "should include include local params with escaping" do
-        expect(@result[:q]).to include('qf=$author_qf')
-        expect(@result[:q]).to include('pf=\'you\\\'ll have \\" to escape this\'')
-        expect(@result[:q]).to include('pf2=$pf2_do_not_escape_or_quote')
+        expect(result[:q]).to include('qf=$author_qf')
+        expect(result[:q]).to include('pf=\'you\\\'ll have \\" to escape this\'')
+        expect(result[:q]).to include('pf2=$pf2_do_not_escape_or_quote')
       end
     end
-    
+
     describe "mapping facet.field" do
       let(:blacklight_config) do
         Blacklight::Configuration.new do |config|
@@ -545,25 +537,27 @@ def params
       end
 
       it "should add single additional facet.field from app" do
-        solr_params = subject.solr_search_params( "facet.field" => "additional_facet" )
+        solr_params = subject.solr_search_params({ "facet.field" => "additional_facet" }, default_method_chain)
         expect(solr_params[:"facet.field"]).to include("additional_facet")
         expect(solr_params[:"facet.field"]).to have(2).fields
       end
+
       it "should map multiple facet.field to additional facet.field" do
-        solr_params = subject.solr_search_params( "facet.field" => ["add_facet1", "add_facet2"] )
+        solr_params = subject.solr_search_params({ "facet.field" => ["add_facet1", "add_facet2"] }, default_method_chain)
         expect(solr_params[:"facet.field"]).to include("add_facet1")
         expect(solr_params[:"facet.field"]).to include("add_facet2")
         expect(solr_params[:"facet.field"]).to have(3).fields
       end
+
       it "should map facets[fields][] to additional facet.field" do
-        solr_params = subject.solr_search_params( "facets" => ["add_facet1", "add_facet2"] )
+        solr_params = subject.solr_search_params({ "facets" => ["add_facet1", "add_facet2"] }, default_method_chain)
         expect(solr_params[:"facet.field"]).to include("add_facet1")
         expect(solr_params[:"facet.field"]).to include("add_facet2")
         expect(solr_params[:"facet.field"]).to have(3).fields
       end
     end
 
- end
+  end
 
   describe "solr_facet_params" do
     before do
@@ -636,24 +630,24 @@ def params
       expect(solr_facet_params).to include :"rows" => 0
     end
   end
-  describe "for facet limit parameters config ed" do                
-    before do   
-      allow(subject).to receive_messages params: {:search_field => "test_field", :q => "test query"}
-      @generated_params = subject.solr_search_params
-    end
 
-    let(:blacklight_config) { copy_of_catalog_config }
-    
-    it "should include specifically configged facet limits +1" do
-      expect(@generated_params[:"f.subject_topic_facet.facet.limit"]).to eq 21      
-    end
-    it "should not include a facet limit for a nil key in hash" do
-      expect(@generated_params).not_to have_key(:"f.format.facet.limit")
-      expect(@generated_params).not_to have_key(:"facet.limit")
-    end
+  describe "for facet limit parameters config ed" do                
+    # subject do
+    #   subject.solr_search_params({ search_field: "test_field", :q => "test query"}, {}, default_method_chain)
+    # end
+
+    # let(:blacklight_config) { copy_of_catalog_config }
+    # 
+    # it "should include specifically configged facet limits +1" do
+    #   expect(subject[:"f.subject_topic_facet.facet.limit"]).to eq 21      
+    # end
+    # it "should not include a facet limit for a nil key in hash" do
+    #   expect(subject).not_to have_key(:"f.format.facet.limit")
+    #   expect(subject).not_to have_key(:"facet.limit")
+    # end
   end
   
-   describe "get_facet_pagination", :integration => true do
+  describe "get_facet_pagination", :integration => true do
     before do
       Deprecation.silence(Blacklight::SolrHelper) do
         @facet_paginator = subject.get_facet_pagination(@facet_field)
@@ -665,16 +659,16 @@ def params
     it 'with a limit set' do
       expect(@facet_paginator.limit).not_to be_nil
     end
-   end
+  end
 
-# SPECS FOR SEARCH RESULTS FOR QUERY
+  # SPECS FOR SEARCH RESULTS FOR QUERY
   describe 'Search Results', :integration => true do
 
     let(:blacklight_config) { copy_of_catalog_config }
     describe 'for a sample query returning results' do
 
-      before do        
-        (@solr_response, @document_list) = subject.get_search_results(:q => @all_docs_query)
+      before do
+        (@solr_response, @document_list) = subject.search_results({ q: @all_docs_query }, {}, default_method_chain)
       end
 
       it "should use the configured request handler " do
@@ -685,7 +679,7 @@ def params
           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'=>"", "spellcheck.q"=>"", "f.subject_topic_facet.facet.limit"=>21, 'sort'=>"score desc, pub_date_sort desc, title_sort asc")
         end.and_return({'response'=>{'docs'=>[]}})
-        subject.get_search_results(:q => @all_docs_query)
+        subject.search_results({ q: @all_docs_query }, {}, default_method_chain)
       end
 
       it 'should have a @response.docs list of the same size as @document_list' do
@@ -706,9 +700,17 @@ def params
       end
     end
 
+    describe "#get_search_results " do
+      it "should be deprecated and call search_results()" do
+        expect(Deprecation).to receive(:warn)
+        expect(subject).to receive(:search_results).with({}, {}, default_method_chain)
+        subject.get_search_results()
+      end
+    end
+
     describe "for a query returning a grouped response" do
       before do
-        (@solr_response, @document_list) = subject.get_search_results({:q => @all_docs_query}, :group => true, :'group.field' => 'pub_date_sort')
+        (@solr_response, @document_list) = subject.search_results({ q: @all_docs_query }, { group: true, :'group.field' => 'pub_date_sort' }, default_method_chain)
       end
 
       it "should have an empty document list" do
@@ -726,7 +728,7 @@ def params
 
       before do
         allow(subject).to receive_messages grouped_key_for_results: 'title_sort'
-        (@solr_response, @document_list) = subject.get_search_results({:q => @all_docs_query}, :group => true, :'group.field' => ['pub_date_sort', 'title_sort'])
+        (@solr_response, @document_list) = subject.search_results({:q => @all_docs_query}, { group: true, :'group.field' => ['pub_date_sort', 'title_sort'] }, default_method_chain)
       end
 
       it "should have an empty document list" do
@@ -741,7 +743,7 @@ def params
 
     describe '#query_solr' do
       it 'should have results' do
-        solr_response = subject.query_solr(:q => @single_word_query)
+        solr_response = subject.query_solr({ q: @single_word_query }, {}, default_method_chain)
         expect(solr_response.docs).to have_at_least(1).result
       end
 
@@ -749,7 +751,7 @@ def params
 
     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.get_search_results(:q => @all_docs_query)
+        (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, {}, default_method_chain)
         result_docs = document_list
         document = result_docs.first
         expect(document.get(blacklight_config.index.title_field)).not_to be_nil
@@ -760,14 +762,13 @@ def params
 
 
     describe "Single Word Query with no Facets" do
-    	
       it 'should have results' do
-        solr_response = subject.query_solr(:q => @single_word_query)
+        solr_response = subject.query_solr({ q: @single_word_query }, {}, default_method_chain)
         expect(solr_response.docs).to have_at_least(1).result
       end
 
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:q => @single_word_query)
+        (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
@@ -776,7 +777,7 @@ def params
     describe "Multiple Words Query with No Facets" do
       it 'should have results' do
 
-        (solr_response, document_list) = subject.get_search_results(:q => @mult_word_query)
+        (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
@@ -784,7 +785,7 @@ def params
 
     describe "One Facet, No Query" do
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:f => @single_facet)
+        (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
@@ -792,7 +793,7 @@ def params
 
     describe "Mult Facets, No Query" do
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:f => @multi_facets)
+        (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
@@ -800,7 +801,7 @@ def params
 
     describe "Single Word Query with One Facet" do
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:q => @single_word_query, :f => @single_facet)
+        (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
@@ -808,7 +809,7 @@ def params
 
     describe "Multiple Words Query with Multiple Facets" do
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:q => @mult_word_query, :f => @multi_facets)
+        (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
@@ -816,7 +817,7 @@ def params
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
-        (solr_response, document_list) = subject.get_search_results(:q => @all_docs_query, :f => @single_facet)
+        (solr_response, document_list) = subject.search_results({ q: @all_docs_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
@@ -826,7 +827,7 @@ def params
 
     describe "for Query Without Results and No Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.get_search_results(:q => @no_docs_query)
+        (solr_response, document_list) = subject.search_results({ q: @no_docs_query }, {}, default_method_chain)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
@@ -834,7 +835,7 @@ def params
 
     describe "for Query Without Results and One Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.get_search_results(:q => @no_docs_query, :f => @single_facet)
+        (solr_response, document_list) = subject.search_results({ q: @no_docs_query, f: @single_facet }, {}, default_method_chain)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
@@ -842,25 +843,21 @@ def params
 
     describe "for All Docs Query and Bad Facet" do
       it 'should have no results and not raise error' do
-        (solr_response, document_list) = subject.get_search_results(:q => @all_docs_query, :f => @bad_facet)
+        (solr_response, document_list) = subject.search_results({ q: @all_docs_query, f: @bad_facet }, {}, default_method_chain)
         expect(document_list).to have(0).results
         expect(solr_response.docs).to have(0).results
       end
     end
-
-
-
-
   end  # Search Results
 
 
-# SPECS FOR SEARCH RESULTS FOR FACETS
+  # SPECS FOR SEARCH RESULTS FOR FACETS
   describe 'Facets in Search Results for All Docs Query', :integration => true do
 
     let(:blacklight_config) { copy_of_catalog_config }
 
     before do
-      (solr_response, document_list) = subject.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = subject.search_results({ q: @all_docs_query}, {}, default_method_chain)
       @facets = solr_response.facets
     end
 
@@ -899,49 +896,49 @@ def params
   end # facet specs
 
 
-# SPECS FOR SEARCH RESULTS FOR PAGING
+  # SPECS FOR SEARCH RESULTS FOR PAGING
   describe 'Paging', :integration => true do
     let(:blacklight_config) { copy_of_catalog_config }
 
     it 'should start with first results by default' do
-      (solr_response, document_list) = subject.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query)
+      (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :per_page => num_results)
+      (solr_response1, document_list1) = subject.search_results({ q: @all_docs_query, per_page: num_results }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :rows => num_results)
+      (solr_response1, document_list1) = subject.search_results({ q: @all_docs_query, rows: num_results }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :page => page)
+      (solr_response2, document_list2) = subject.search_results({ q: @all_docs_query, page: page }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :per_page => num_results, :page => page)
+      (solr_response2a, document_list2a) = subject.search_results({ q: @all_docs_query, per_page: num_results, page: page }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :rows => big, :page => big)
+      (solr_response3, document_list3) = subject.search_results({ q: @all_docs_query, rows: big, page: big }, {}, default_method_chain)
       expect(document_list3).to have(0).docs
       expect(solr_response3.docs).to have(0).docs
     end
@@ -949,12 +946,12 @@ def params
     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.get_search_results(:q => @all_docs_query, :page => '-1')
+      (solr_response4, document_list4) = subject.search_results({ q: @all_docs_query, page: '-1' }, {}, default_method_chain)
       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.get_search_results(:q => @all_docs_query, :rows => big, :page => 1)
+      (solr_response5, document_list5) = subject.search_results({ q: @all_docs_query, rows: big, page: 1 }, {}, default_method_chain)
       expect(solr_response5.docs).to have(document_list5.length).docs
       expect(solr_response5.docs).to have_at_least(1).doc
     end
@@ -1101,13 +1098,13 @@ def params
 # 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.get_search_results({:q => 'boo'})
+      (solr_response, document_list) = subject.search_results({ q: 'boo' }, {}, default_method_chain)
       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.get_search_results({:q => 'politica'})
+      (solr_response, document_list) = subject.search_results({ q: 'politica' }, {}, default_method_chain)
       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
@@ -1120,17 +1117,17 @@ def params
     end
 
     it "title search results for just-poor-enough query term should have spelling suggestions" do
-      (solr_response, document_list) = subject.get_search_results({:q => 'yehudiyam', :qt => 'search', :"spellcheck.dictionary" => "title"})
+      (solr_response, document_list) = subject.search_results({ q: 'yehudiyam', qt: 'search', :"spellcheck.dictionary" => "title" }, {}, default_method_chain)
       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.get_search_results({:q => 'shirma', :qt => 'search', :"spellcheck.dictionary" => "author"})
+      (solr_response, document_list) = subject.search_results({ q: 'shirma', qt: 'search', :"spellcheck.dictionary" => "author" }, {}, default_method_chain)
       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.get_search_results({:q => 'wome', :qt => 'search', :"spellcheck.dictionary" => "subject"})
+      (solr_response, document_list) = subject.search_results({ q: 'wome', qt: 'search', :"spellcheck.dictionary" => "subject" }, {}, default_method_chain)
       expect(solr_response.spelling.words).to include('women')
     end
 
@@ -1148,7 +1145,7 @@ def params
       expect(subject.facet_limit_for("subject_topic_facet")).to eq blacklight_config.facet_fields["subject_topic_facet"].limit
     end
     it "should generate proper solr param" do
-      expect(subject.solr_search_params[:"f.subject_topic_facet.facet.limit"]).to eq 21
+      expect(subject.solr_search_params({}, default_method_chain)[:"f.subject_topic_facet.facet.limit"]).to eq 21
     end
     
     it "facet_limit_hash should return hash with key being facet_field and value being configured limit" do
@@ -1156,12 +1153,11 @@ def params
       skip "facet_limit_hash has been removed from solrhelper in refactor. should it go back?"
       expect(subject.facet_limit_hash).to eq blacklight_config[:facet][:limits]
     end
+
     it "should handle no facet_limits in config" do
       blacklight_config.facet_fields = {}
-            
       expect(subject.facet_limit_for("subject_topic_facet")).to be_nil
-      
-      expect(subject.solr_search_params).not_to have_key(:"f.subject_topic_facet.facet.limit")
+      expect(subject.solr_search_params({}, default_method_chain)).not_to have_key(:"f.subject_topic_facet.facet.limit")
     end
 
     describe "for 'true' configured values" do
@@ -1201,7 +1197,7 @@ def params
 
       it "should enforce max_per_page against all parameters" do
         expect(blacklight_config.max_per_page).to eq 123
-        expect(subject.solr_search_params(:per_page => 98765)[:rows]).to eq 123
+        expect(subject.solr_search_params({ per_page: 98765 }, default_method_chain)[:rows]).to eq 123
       end              
     end
 
@@ -1241,7 +1237,7 @@ def params
 #  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 { subject.query_solr }.to raise_exception(/Unable to connect to Solr instance/)
+    expect { subject.query_solr({}, {}, default_method_chain) }.to raise_exception(/Unable to connect to Solr instance/)
   end
 
   describe "grouped_key_for_results" do
@@ -1266,7 +1262,7 @@ def params
 
   describe "#get_previous_and_next_documents_for_search" do
     before do
-      @full_response, @all_docs = subject.get_search_results({:q => ''}, :rows => 1000)
+      @full_response, @all_docs = subject.search_results({ q: '' }, { rows: 1000 }, default_method_chain)
     end
 
     it "should return the previous and next documents for a search" do
diff --git a/spec/views/catalog/_constraints.html.erb_spec.rb b/spec/views/catalog/_constraints.html.erb_spec.rb
index 2902516083..21feed3b3a 100644
--- a/spec/views/catalog/_constraints.html.erb_spec.rb
+++ b/spec/views/catalog/_constraints.html.erb_spec.rb
@@ -32,4 +32,4 @@
     expect(rendered).to have_link("Start Over", :href => 'http://xyz?view=xyz')
   end
 
-end
\ No newline at end of file
+end
diff --git a/spec/views/catalog/_paginate_compact.html.erb_spec.rb b/spec/views/catalog/_paginate_compact.html.erb_spec.rb
index 6d2c4a8f39..70d67b9ead 100644
--- a/spec/views/catalog/_paginate_compact.html.erb_spec.rb
+++ b/spec/views/catalog/_paginate_compact.html.erb_spec.rb
@@ -18,7 +18,7 @@ def facet_limit_for *args
     include Blacklight::SolrHelper
 
     it "should render solr responses" do
-      solr_response, document_list = get_search_results(:q => '')
+      solr_response, document_list = search_results({ q: '' }, {}, CatalogController.solr_search_params_logic)
 
       render :partial => 'catalog/paginate_compact', :object => solr_response
       expect(rendered).to have_selector ".page_entries"
diff --git a/spec/views/catalog/index.atom.builder_spec.rb b/spec/views/catalog/index.atom.builder_spec.rb
index edd828ad35..a00be254ab 100644
--- a/spec/views/catalog/index.atom.builder_spec.rb
+++ b/spec/views/catalog/index.atom.builder_spec.rb
@@ -15,7 +15,7 @@
     # run a solr query to get our data
     c = CatalogController.new
     c.blacklight_config = @config
-    @response, @document_list = c.get_search_results(@params)
+    @response, @document_list = c.search_results(@params, {}, c.solr_search_params_logic)
 
     # munge the solr response to match test expectations
     @document_list[1] = SolrDocument.new(@document_list[1].with_indifferent_access.reject! { |k,v| k == "author_display" })