blacklight 4.7.0 → 4.8.0

data/spec/lib/search_fields_spec.rb

@@ -21,12 +21,12 @@ describe Blacklight::SearchFields do
 
   before(:each) do  
     @search_field_obj = MockConfig.new
-    @search_field_obj.stub(:blacklight_config).and_return(@config)
+    allow(@search_field_obj).to receive(:blacklight_config).and_return(@config)
   end
 
   it "should return search field list with calculated :label when needed" do
      @search_field_obj.search_field_list.each do |hash|        
-        hash.label.should_not be_blank
+        expect(hash.label).not_to be_blank
      end
   end
 
@@ -42,30 +42,30 @@ describe Blacklight::SearchFields do
        argument = select_arguments[index]
        config_hash = @search_field_obj.search_field_list[index]
 
-       argument.length.should == 2
-       argument[0].should == config_hash.label
-       argument[1].should == config_hash.key
+       expect(argument.length).to eq(2)
+       expect(argument[0]).to eq(config_hash.label)
+       expect(argument[1]).to eq(config_hash.key)
     end    
   end
 
   it "should not include fields in select if :display_in_simple_search=>false" do
     select_arguments = @search_field_obj.search_field_options_for_select
 
-    select_arguments.should_not include(["No Display", "no_display"])
+    expect(select_arguments).not_to include(["No Display", "no_display"])
   end
 
   
 
   it "should lookup field definitions by key" do
-    @search_field_obj.search_field_def_for_key("title").key.should == "title"
+    expect(@search_field_obj.search_field_def_for_key("title").key).to eq("title")
   end
 
   it "should find label by key" do
-    @search_field_obj.label_for_search_field("title").should == "Title"
+    expect(@search_field_obj.label_for_search_field("title")).to eq("Title")
   end
 
   it "should supply default label for key not found" do
-    @search_field_obj.label_for_search_field("non_existent_key").should == "Keyword"
+    expect(@search_field_obj.label_for_search_field("non_existent_key")).to eq("Keyword")
   end
 
   describe "for unspecified :key" do
@@ -73,10 +73,10 @@ describe Blacklight::SearchFields do
       @bad_config = MockConfig.new
     end
     it "should raise exception on #search_field_list" do
-      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
+      expect { allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
            config.add_search_field :label => 'All Fields', :qt => 'all_fields'
            config.add_search_field 'title', :qt => 'title_search'
-      })   }.should raise_error
+      })   }.to raise_error
     end
   end
 
@@ -85,11 +85,11 @@ describe Blacklight::SearchFields do
       @bad_config = MockConfig.new
     end
     it "should raise on #search_field_list" do
-      lambda { @bad_config.stub(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
+      expect { allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new { |config|
         config.add_search_field 'my_key', :label => 'All Fields'
         config.add_search_field 'my_key', :label => 'title'
 
-      }) }.should raise_error
+      }) }.to raise_error
     end
   end
   

data/spec/lib/solr_helper_spec.rb

@@ -26,7 +26,7 @@ describe 'Blacklight::SolrHelper' do
   def blacklight_config
     @config ||= CatalogController.blacklight_config
   end
-  
+
   def blacklight_config=(config)
     @config = config
   end
@@ -51,25 +51,25 @@ describe 'Blacklight::SolrHelper' do
     @subject_search_params = {:commit=>"search", :search_field=>"subject", :action=>"index", :"controller"=>"catalog", :"rows"=>"10", :"q"=>"wome"}
   end
 
-  
+
 
   # SPECS for actual search parameter generation
   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.
         def add_foo_to_solr_params(solr_params, user_params)
           solr_params[:foo] = "TESTING"
         end
- 
-                         
+
+
         self.solr_search_params_logic += [:add_foo_to_solr_params]
-        
-        
-        self.solr_search_params[:foo].should == "TESTING"                
+
+
+        expect(self.solr_search_params[:foo]).to eq("TESTING")
     end
-    
-    
+
+
     describe 'for an entirely empty search' do
        def params
           {}
@@ -78,40 +78,40 @@ describe 'Blacklight::SolrHelper' do
         @produced_params = self.solr_search_params
       end
       it 'should not have a q param' do
-        @produced_params[:q].should be_nil
-        @produced_params["spellcheck.q"].should be_nil
+        expect(@produced_params[:q]).to be_nil
+        expect(@produced_params["spellcheck.q"]).to be_nil
       end
       it 'should have default rows' do
-        @produced_params[:rows].should == 10
+        expect(@produced_params[:rows]).to eq(10)
       end
       it 'should have default facet fields' do
         # remove local params from the facet.field
-        @produced_params[:"facet.field"].map { |x| x.gsub(/\{![^}]+\}/, '') }.should == blacklight_config.facet_fields_to_add_to_solr
+        expect(@produced_params[:"facet.field"].map { |x| x.gsub(/\{![^}]+\}/, '') }).to eq(blacklight_config.facet_fields_to_add_to_solr)
       end
-      
+
       it "should have default qt"  do
-        @produced_params[:qt].should == "search"
+        expect(@produced_params[:qt]).to eq("search")
       end
       it "should have no fq" do
-        @produced_params[:phrase_filters].should be_blank
-        @produced_params[:fq].should be_blank
+        expect(@produced_params[:phrase_filters]).to be_blank
+        expect(@produced_params[:fq]).to be_blank
       end
     end
 
 
-    describe "for an empty string search" do      
-      it "should return empty string q in solr parameters" do        
+    describe "for an empty string search" do
+      it "should return empty string q in solr parameters" do
         solr_params = solr_search_params(:q => "")
-        solr_params[:q].should == ""
-        solr_params["spellcheck.q"].should == ""
+        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 'q' key, as symbol" do        
+    describe "for request params also passed in as argument" do
+      it "should only have one 'q' key, as symbol" do
         solr_params = solr_search_params( :q => "some query" )
-        solr_params.keys.should include(:q)
-        solr_params.keys.should_not include("q")
+        expect(solr_params.keys).to include(:q)
+        expect(solr_params.keys).not_to include("q")
       end
     end
 
@@ -121,11 +121,11 @@ describe 'Blacklight::SolrHelper' do
 
         solr_params = solr_search_params(:f => @single_facet)
 
-        solr_params[:q].should be_blank
-        solr_params["spellcheck.q"].should be_blank
+        expect(solr_params[:q]).to be_blank
+        expect(solr_params["spellcheck.q"]).to be_blank
 
         @single_facet.each_value do |value|
-          solr_params[:fq].should include("{!raw f=#{@single_facet.keys[0]}}#{value}")
+          expect(solr_params[:fq]).to include("{!raw f=#{@single_facet.keys[0]}}#{value}")
         end
       end
     end
@@ -138,7 +138,7 @@ describe 'Blacklight::SolrHelper' do
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
+            expect(solr_params[:fq]).to include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
 
@@ -153,10 +153,10 @@ describe 'Blacklight::SolrHelper' do
           value_list ||= []
           value_list = [value_list] unless value_list.respond_to? :each
           value_list.each do |value|
-            solr_params[:fq].should include("{!raw f=#{facet_field}}#{value}"  )
+            expect(solr_params[:fq]).to include("{!raw f=#{facet_field}}#{value}"  )
           end
         end
-        solr_params[:q].should == @mult_word_query
+        expect(solr_params[:q]).to eq(@mult_word_query)
       end
     end
 
@@ -167,48 +167,60 @@ describe 'Blacklight::SolrHelper' do
       end
 
       it "should use the raw handler for strings" do
-        facet_value_to_fq_string("facet_name", "my value").should  == "{!raw f=facet_name}my value" 
+        expect(facet_value_to_fq_string("facet_name", "my value")).to  eq("{!raw f=facet_name}my value")
       end
 
       it "should pass booleans through" do
-        facet_value_to_fq_string("facet_name", true).should  == "facet_name:true"
+        expect(facet_value_to_fq_string("facet_name", true)).to  eq("facet_name:true")
       end
 
       it "should pass boolean-like strings through" do
-        facet_value_to_fq_string("facet_name", "true").should  == "facet_name:true"
+        expect(facet_value_to_fq_string("facet_name", "true")).to  eq("facet_name:true")
       end
 
       it "should pass integers through" do
-        facet_value_to_fq_string("facet_name", 1).should  == "facet_name:1"
+        expect(facet_value_to_fq_string("facet_name", 1)).to  eq("facet_name:1")
       end
 
       it "should pass integer-like strings through" do
-        facet_value_to_fq_string("facet_name", "1").should  == "facet_name:1"
+        expect(facet_value_to_fq_string("facet_name", "1")).to  eq("facet_name:1")
       end
 
       it "should pass floats through" do
-        facet_value_to_fq_string("facet_name", 1.11).should  == "facet_name:1.11"
+        expect(facet_value_to_fq_string("facet_name", 1.11)).to  eq("facet_name:1.11")
       end
 
       it "should pass floats through" do
-        facet_value_to_fq_string("facet_name", "1.11").should  == "facet_name:1.11"
+        expect(facet_value_to_fq_string("facet_name", "1.11")).to  eq("facet_name:1.11")
       end
 
       it "should pass date-type fields through" do
-        blacklight_config.facet_fields.stub(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
+        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
+
+        expect(facet_value_to_fq_string("facet_name", "2012-01-01")).to eq "facet_name:2012\\-01\\-01"
+      end
+
+      it "should escape datetime-type fields" do
+        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => true, :query => nil, :tag => nil))
 
-        facet_value_to_fq_string("facet_name", "2012-01-01").should  == "facet_name:2012-01-01"
+        expect(facet_value_to_fq_string("facet_name", "2003-04-09T00:00:00Z")).to eq "facet_name:2003\\-04\\-09T00\\:00\\:00Z"
+      end
+
+      it "should format Date objects correctly" do
+        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:date => nil, :query => nil, :tag => nil))
+        d = DateTime.parse("2003-04-09T00:00:00")
+        expect(facet_value_to_fq_string("facet_name", d)).to eq "facet_name:2003\\-04\\-09T00\\:00\\:00Z"
       end
 
       it "should handle range requests" do
-        facet_value_to_fq_string("facet_name", 1..5).should  == "facet_name:[1 TO 5]"
+        expect(facet_value_to_fq_string("facet_name", 1..5)).to  eq("facet_name:[1 TO 5]")
       end
 
       it "should add tag local parameters" do
-        blacklight_config.facet_fields.stub(:[]).with('facet_name').and_return(double(:query => nil, :tag => 'asdf', :date => nil))
+        allow(blacklight_config.facet_fields).to receive(:[]).with('facet_name').and_return(double(:query => nil, :tag => 'asdf', :date => nil))
 
-        facet_value_to_fq_string("facet_name", true).should  == "{!tag=asdf}facet_name:true"
-        facet_value_to_fq_string("facet_name", "my value").should  == "{!raw f=facet_name tag=asdf}my value"
+        expect(facet_value_to_fq_string("facet_name", true)).to  eq("{!tag=asdf}facet_name:true")
+        expect(facet_value_to_fq_string("facet_name", "my value")).to  eq("{!raw f=facet_name tag=asdf}my value")
       end
     end
 
@@ -217,29 +229,29 @@ describe 'Blacklight::SolrHelper' do
         @solr_params = solr_search_params( @subject_search_params )
       end
       it "should look up qt from field definition" do
-        @solr_params[:qt].should == "search"
+        expect(@solr_params[:qt]).to eq("search")
       end
       it "should not include weird keys not in field definition" do
-        @solr_params[:phrase_filters].should be_nil
-        @solr_params[:fq].should be_nil
-        @solr_params[:commit].should be_nil
-        @solr_params[:action].should be_nil
-        @solr_params[:controller].should be_nil
+        expect(@solr_params[:phrase_filters]).to be_nil
+        expect(@solr_params[:fq]).to be_nil
+        expect(@solr_params[:commit]).to be_nil
+        expect(@solr_params[:action]).to be_nil
+        expect(@solr_params[:controller]).to be_nil
       end
       it "should include proper 'q', possibly with LocalParams" do
-        @solr_params[:q].should match(/(\{[^}]+\})?wome/)
+        expect(@solr_params[:q]).to match(/(\{[^}]+\})?wome/)
       end
       it "should include proper 'q' when LocalParams are used" do
         if @solr_params[:q] =~ /\{[^}]+\}/
-          @solr_params[:q].should match(/\{[^}]+\}wome/)
+          expect(@solr_params[:q]).to match(/\{[^}]+\}wome/)
         end
       end
       it "should include spellcheck.q, without LocalParams" do
-        @solr_params["spellcheck.q"].should == "wome"
+        expect(@solr_params["spellcheck.q"]).to eq("wome")
       end
 
       it "should include spellcheck.dictionary from field def solr_parameters" do
-        @solr_params[:"spellcheck.dictionary"].should == "subject"
+        expect(@solr_params[:"spellcheck.dictionary"]).to eq("subject")
       end
       it "should add on :solr_local_parameters using Solr LocalParams style" do
         params = solr_search_params( @subject_search_params )
@@ -248,8 +260,8 @@ describe 'Blacklight::SolrHelper' do
         #the LocalParams are really there
         params[:q] =~ /^\{!([^}]+)\}/
         key_value_pairs = $1.split(" ")
-        key_value_pairs.should include("pf=$subject_pf")
-        key_value_pairs.should include("qf=$subject_qf")
+        expect(key_value_pairs).to include("pf=$subject_pf")
+        expect(key_value_pairs).to include("qf=$subject_qf")
       end
     end
 
@@ -258,18 +270,18 @@ describe 'Blacklight::SolrHelper' do
         def params
           super.merge(:qt => "overridden")
         end
-        
-        solr_search_params[:qt].should == "overridden"        
+
+        expect(solr_search_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' }
-        
+
         add_facet_fq_to_solr(solr_parameters, {})
 
-        solr_parameters[:fq].should be_a_kind_of Array
+        expect(solr_parameters[:fq]).to be_a_kind_of Array
       end
     end
 
@@ -289,13 +301,13 @@ describe 'Blacklight::SolrHelper' do
       it "should return the correct solr parameters" do
 
         solr_parameters = { }
-        
+
         add_facetting_to_solr(solr_parameters, {})
 
-        expect(solr_parameters[:facet]).to be_true
+        expect(solr_parameters[:facet]).to eq true
 
-        solr_parameters[:'facet.field'].should include('test_field')
-        solr_parameters[:'f.test_field.facet.sort'].should == 'count'
+        expect(solr_parameters[:'facet.field']).to include('test_field')
+        expect(solr_parameters[:'f.test_field.facet.sort']).to eq('count')
       end
 
       it "should add facet exclusions" do
@@ -303,33 +315,33 @@ describe 'Blacklight::SolrHelper' do
 
         add_facetting_to_solr(solr_parameters, {})
 
-        solr_parameters[:'facet.query'].should include('{!ex=xyz}some:query')
-        solr_parameters[:'facet.pivot'].should include('{!ex=xyz}a,b')
+        expect(solr_parameters[:'facet.query']).to include('{!ex=xyz}some:query')
+        expect(solr_parameters[:'facet.pivot']).to include('{!ex=xyz}a,b')
       end
     end
 
     describe "with a complex parameter environment" do
-      def blacklight_config          
+      def blacklight_config
         config = Blacklight::Configuration.new
         config.add_search_field("test_field",
-                             :display_label => "Test", 
-                             :key=>"test_field", 
+                             :display_label => "Test",
+                             :key=>"test_field",
                              :solr_parameters => {:qf => "fieldOne^2.3 fieldTwo fieldThree^0.4", :pf => "", :spellcheck => 'false', :rows => "55", :sort => "request_params_sort" }
                             )
         return config
       end
-      def params          
+      def params
         {:search_field => "test_field", :q => "test query", "facet.field" => "extra_facet"}
       end
-      
+
       it "should merge parameters from search_field definition" do
         solr_params = solr_search_params
-        
-        solr_params[:qf].should == "fieldOne^2.3 fieldTwo fieldThree^0.4"
-        solr_params[:spellcheck].should == 'false'
+
+        expect(solr_params[:qf]).to eq("fieldOne^2.3 fieldTwo fieldThree^0.4")
+        expect(solr_params[:spellcheck]).to eq('false')
       end
       it "should merge empty string parameters from search_field definition" do
-        solr_search_params[:pf].should == ""        
+        expect(solr_search_params[:pf]).to eq("")
       end
 
       describe "should respect proper precedence of settings, " do
@@ -339,53 +351,53 @@ describe 'Blacklight::SolrHelper' do
 
 
         it "should not put :search_field in produced params" do
-          @produced_params[:search_field].should 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
-          @produced_params[:qt].should == 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
-          @produced_params[:rows].should == "55"
+          expect(@produced_params[:rows]).to eq("55")
         end
 
         it "should take q from request params" do
-          @produced_params[:q].should == "test query"
+          expect(@produced_params[:q]).to eq("test query")
         end
 
         it "should add in extra facet.field from params" do
-          @produced_params[:"facet.field"].should include("extra_facet")
+          expect(@produced_params[:"facet.field"]).to include("extra_facet")
         end
 
       end
     end
 
     describe "sorting" do
-      
-      it "should send the default sort parameter to solr" do                        
-        solr_search_params[:sort].should == 'score desc, pub_date_sort desc, title_sort asc'        
+
+      it "should send the default sort parameter to solr" do
+        expect(solr_search_params[: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
-        def blacklight_config          
+        def blacklight_config
           config = Blacklight::Configuration.new
           config.add_sort_field('', :label => 'test')
           return config
         end
 
         produced_params = solr_search_params
-        produced_params.should_not have_key(:sort)
+        expect(produced_params).not_to have_key(:sort)
       end
 
       it "should pass through user sort parameters" do
         produced_params = solr_search_params( :sort => 'solr_test_field desc' )
-        produced_params[:sort].should == 'solr_test_field desc'
+        expect(produced_params[:sort]).to eq('solr_test_field desc')
       end
     end
 
     describe "for :solr_local_parameters config" do
-      def blacklight_config          
+      def blacklight_config
         config = Blacklight::Configuration.new
         config.add_search_field(
           "custom_author_key",
@@ -404,45 +416,45 @@ describe 'Blacklight::SolrHelper' do
         )
         return config
       end
-      
-      def params        
+
+      def params
         {:search_field => "custom_author_key", :q => "query"}
       end
-      
+
       before do
         @result = solr_search_params
       end
 
       it "should pass through ordinary params" do
-        @result[:qt].should == "author_qt"
-        @result[:ps].should == "2"
-        @result[:qf].should == "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
-        @result[:q].should include('qf=$author_qf')
-        @result[:q].should include('pf=\'you\\\'ll have \\" to escape this\'')
-        @result[:q].should 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
       it "should add single additional facet.field from app" do
         solr_params = solr_search_params( "facet.field" => "additional_facet" )
-        solr_params[:"facet.field"].should include("additional_facet")
-        solr_params[:"facet.field"].length.should > 1
+        expect(solr_params[:"facet.field"]).to include("additional_facet")
+        expect(solr_params[:"facet.field"].length).to be > 1
       end
       it "should map multiple facet.field to additional facet.field" do
         solr_params = solr_search_params( "facet.field" => ["add_facet1", "add_facet2"] )
-        solr_params[:"facet.field"].should include("add_facet1")
-        solr_params[:"facet.field"].should include("add_facet2")
-        solr_params[:"facet.field"].length.should > 2
+        expect(solr_params[:"facet.field"]).to include("add_facet1")
+        expect(solr_params[:"facet.field"]).to include("add_facet2")
+        expect(solr_params[:"facet.field"].length).to be > 2
       end
       it "should map facets[fields][] to additional facet.field" do
         solr_params = solr_search_params( "facets" => ["add_facet1", "add_facet2"] )
-        solr_params[:"facet.field"].should include("add_facet1")
-        solr_params[:"facet.field"].should include("add_facet2")
-        solr_params[:"facet.field"].length.should > 2
+        expect(solr_params[:"facet.field"]).to include("add_facet1")
+        expect(solr_params[:"facet.field"]).to include("add_facet2")
+        expect(solr_params[:"facet.field"].length).to be > 2
       end
     end
 
@@ -464,21 +476,21 @@ describe 'Blacklight::SolrHelper' do
       end
     end
     it 'sets rows to 0' do
-      @generated_solr_facet_params[:rows].should == 0
+      expect(@generated_solr_facet_params[:rows]).to eq(0)
     end
     it 'sets facets requested to facet_field argument' do
-      @generated_solr_facet_params["facet.field".to_sym].should == @facet_field
+      expect(@generated_solr_facet_params["facet.field".to_sym]).to eq(@facet_field)
     end
     it 'defaults offset to 0' do
-      @generated_solr_facet_params[:"f.#{@facet_field}.facet.offset"].should == 0
+      expect(@generated_solr_facet_params[:"f.#{@facet_field}.facet.offset"]).to eq(0)
     end
     it 'uses offset manually set, and converts it to an integer' do
       solr_params = solr_facet_params(@facet_field, @page_key => 2)
-      solr_params[:"f.#{@facet_field}.facet.offset"].should == 20
+      expect(solr_params[:"f.#{@facet_field}.facet.offset"]).to eq(20)
     end
     it 'defaults limit to 20' do
       solr_params = solr_facet_params(@facet_field)
-      solr_params[:"f.#{@facet_field}.facet.limit"].should == 21
+      expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(21)
     end
 
     describe 'if facet_list_limit is defined in controller' do
@@ -487,29 +499,29 @@ describe 'Blacklight::SolrHelper' do
       end
       it 'uses controller method for limit' do
         solr_params = solr_facet_params(@facet_field)
-        solr_params[:"f.#{@facet_field}.facet.limit"].should == 1001
+        expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(1001)
       end
 
       it 'uses controller method for limit when a ordinary limit is set' do
         solr_params = solr_facet_params(@facet_field)
-        solr_params[:"f.#{@facet_field}.facet.limit"].should == 1001
+        expect(solr_params[:"f.#{@facet_field}.facet.limit"]).to eq(1001)
       end
     end
 
     it 'uses the default sort' do
       solr_params = solr_facet_params(@facet_field)
-      solr_params[:"f.#{@facet_field}.facet.sort"].should be_blank
+      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to be_blank
     end
 
     it "uses the field-specific sort" do
       @facet_field = 'format_ordered'
       solr_params = solr_facet_params(@facet_field)
-      solr_params[:"f.#{@facet_field}.facet.sort"].should == :count
+      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to eq(:count)
     end
 
     it 'uses sort provided in the parameters' do
       solr_params = solr_facet_params(@facet_field, @sort_key => "index")
-      solr_params[:"f.#{@facet_field}.facet.sort"].should == 'index'
+      expect(solr_params[:"f.#{@facet_field}.facet.sort"]).to eq('index')
     end
     it "comes up with the same params as #solr_search_params to constrain context for facet list" do
       search_params = {:q => 'tibetan history', :f=> {:format=>'Book', :language_facet=>'Tibetan'}}
@@ -521,39 +533,39 @@ describe 'Blacklight::SolrHelper' do
         # don't care about.
         next if [:facets, "facet.field".to_sym, :rows, 'facet.limit', 'facet.offset', 'facet.sort'].include?(key)
         # Everything else should match
-        solr_facet_params[key].should == value
+        expect(solr_facet_params[key]).to eq(value)
       end
 
     end
   end
-  describe "for facet limit parameters config ed" do              
+  describe "for facet limit parameters config ed" do
     def params
       {:search_field => "test_field", :q => "test query"}
     end
-    
-    
-    before do            
+
+
+    before do
       @generated_params = solr_search_params
     end
-    
+
     it "should include specifically configged facet limits +1" do
-      @generated_params[:"f.subject_topic_facet.facet.limit"].should == 21      
+      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
-      @generated_params.should_not have_key(:"f.format.facet.limit")
-      @generated_params.should_not have_key(:"facet.limit")
+      expect(@generated_params).not_to have_key(:"f.format.facet.limit")
+      expect(@generated_params).not_to have_key(:"facet.limit")
     end
   end
-  
+
    describe "get_facet_pagination", :integration => true do
     before(:each) do
       @facet_paginator = get_facet_pagination(@facet_field)
     end
     it 'should return a facet paginator' do
-      @facet_paginator.should be_a_kind_of(Blacklight::Solr::FacetPaginator)
+      expect(@facet_paginator).to be_a_kind_of(Blacklight::Solr::FacetPaginator)
     end
     it 'with a limit set' do
-      @facet_paginator.limit.should_not be_nil
+      expect(@facet_paginator.limit).not_to be_nil
     end
    end
 
@@ -562,23 +574,23 @@ describe 'Blacklight::SolrHelper' do
 
     describe 'for a sample query returning results' do
 
-      before(:all) do        
+      before(:all) do
         (@solr_response, @document_list) = get_search_results(:q => @all_docs_query)
       end
 
       it "should use the configured request handler " do
-        blacklight_config.stub(:default_solr_params).and_return({:qt => 'custom_request_handler'})
-        blacklight_solr.should_receive(:send_and_receive) do |path, params|
-          path.should == 'select'
-          params[:params][:'facet.field'].should == ["format", "{!ex=pub_date_single}pub_date", "subject_topic_facet", "language_facet", "lc_1letter_facet", "subject_geo_facet", "subject_era_facet"]
-          params[:params][:"facet.query"].should == ["pub_date:[#{5.years.ago.year} TO *]", "pub_date:[#{10.years.ago.year} TO *]", "pub_date:[#{25.years.ago.year} TO *]"]
-          params[:params].should 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'=>[]}})
+        allow(blacklight_config).to receive(:default_solr_params).and_return({:qt => 'custom_request_handler'})
+        expect(blacklight_solr).to receive(:send_and_receive) { |path, params|
+          expect(path).to eq('select')
+          expect(params[:params][:'facet.field']).to eq(["format", "{!ex=pub_date_single}pub_date", "subject_topic_facet", "language_facet", "lc_1letter_facet", "subject_geo_facet", "subject_era_facet"])
+          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")
+        }.and_return({'response'=>{'docs'=>[]}})
         get_search_results(:q => @all_docs_query)
       end
 
       it 'should have a @response.docs list of the same size as @document_list' do
-        @solr_response.docs.length.should == @document_list.length
+        expect(@solr_response.docs.length).to eq(@document_list.length)
       end
 
       it 'should have @response.docs list representing same documents as SolrDocuments in @document_list' do
@@ -586,10 +598,10 @@ describe 'Blacklight::SolrHelper' do
           mash = @solr_response.docs[index]
           solr_document = @document_list[index]
 
-          Set.new(mash.keys).should == Set.new(solr_document.keys)
+          expect(Set.new(mash.keys)).to eq(Set.new(solr_document.keys))
 
           mash.each_key do |key|
-            mash[key].should == solr_document[key]
+            expect(mash[key]).to eq(solr_document[key])
           end
         end
       end
@@ -632,7 +644,7 @@ describe 'Blacklight::SolrHelper' do
     describe '#query_solr' do
       it 'should have results' do
         solr_response = query_solr(:q => @single_word_query)
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to be > 0
       end
 
     end
@@ -642,24 +654,24 @@ describe 'Blacklight::SolrHelper' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query)
         result_docs = document_list
         document = result_docs.first
-        document.get(blacklight_config.index.show_link).should_not == nil
-        document.get(blacklight_config.index.record_display_type).should_not == nil
+        expect(document.get(blacklight_config.index.show_link)).not_to eq(nil)
+        expect(document.get(blacklight_config.index.record_display_type)).not_to eq(nil)
       end
     end
 
 
 
     describe "Single Word Query with no Facets" do
-    	
+
       it 'should have results' do
         solr_response = query_solr(:q => @single_word_query)
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to be > 0
       end
 
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @single_word_query)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
@@ -667,48 +679,48 @@ describe 'Blacklight::SolrHelper' do
       it 'should have results' do
 
         (solr_response, document_list) = get_search_results(:q => @mult_word_query)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
     describe "One Facet, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @single_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
     describe "Mult Facets, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @multi_facets)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
     describe "Single Word Query with One Facet" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @single_word_query, :f => @single_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
     describe "Multiple Words Query with Multiple Facets" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @mult_word_query, :f => @multi_facets)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
     end
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @single_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to be > 0
       end
       # TODO: check that number of these results < number of results for all docs query
       #   BUT can't: num docs isn't total, it's the num docs in the single SOLR response (e.g. 10)
@@ -717,24 +729,24 @@ describe 'Blacklight::SolrHelper' do
     describe "for Query Without Results and No Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @no_docs_query)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should == 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to eq(0)
       end
     end
 
     describe "for Query Without Results and One Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @no_docs_query, :f => @single_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should == 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to eq(0)
       end
     end
 
     describe "for All Docs Query and Bad Facet" do
       it 'should have no results and not raise error' do
         (solr_response, document_list) = get_search_results(:q => @all_docs_query, :f => @bad_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should == 0
+        expect(solr_response.docs.size).to eq(document_list.size)
+        expect(solr_response.docs.size).to eq(0)
       end
     end
 
@@ -753,16 +765,16 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it 'should have more than one facet' do
-      @facets.size.should > 1
+      expect(@facets.size).to be > 1
     end
-    it 'should have all facets specified in initializer' do      
+    it 'should have all facets specified in initializer' do
       blacklight_config.facet_fields_to_add_to_solr.each do |field|
-        @facets.find {|f| f.name == field}.should_not be_nil        
+        expect(@facets.find {|f| f.name == field}).not_to be_nil
       end
     end
     it 'should have at least one value for each facet' do
       @facets.each do |facet|
-        facet.items.size.should > 0
+        expect(facet.items.size).to be > 0
       end
     end
     it 'should have multiple values for at least one facet' do
@@ -773,7 +785,7 @@ describe 'Blacklight::SolrHelper' do
           break
         end
       end
-      has_mult_values.should == true
+      expect(has_mult_values).to eq(true)
     end
     it 'should have all value counts > 0' do
       @facets.each do |facet|
@@ -790,58 +802,58 @@ describe 'Blacklight::SolrHelper' do
 
     it 'should start with first results by default' do
       (solr_response, document_list) = get_search_results(:q => @all_docs_query)
-      solr_response.params[:start].to_i.should == 0
+      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) = get_search_results(:q => @all_docs_query)
-      solr_response.docs.size.should == document_list.size
-      solr_response.docs.size.should == blacklight_config[:default_solr_params][:rows]
+      expect(solr_response.docs.size).to eq(document_list.size)
+      expect(solr_response.docs.size).to eq(blacklight_config[:default_solr_params][:rows])
     end
 
     it 'should get number of results per page requested' do
       num_results = 3  # non-default value
       (solr_response1, document_list1) = get_search_results(:q => @all_docs_query, :per_page => num_results)
-      solr_response1.docs.size.should == document_list1.size
-      solr_response1.docs.size.should == num_results
+      expect(solr_response1.docs.size).to eq(document_list1.size)
+      expect(solr_response1.docs.size).to eq(num_results)
     end
 
     it 'should get number of rows requested' do
       num_results = 4  # non-default value
       (solr_response1, document_list1) = get_search_results(:q => @all_docs_query, :rows => num_results)
-      solr_response1.docs.size.should == document_list1.size
-      solr_response1.docs.size.should == num_results
+      expect(solr_response1.docs.size).to eq(document_list1.size)
+      expect(solr_response1.docs.size).to eq(num_results)
     end
 
     it 'should skip appropriate number of results when requested - default per page' do
       page = 3
       (solr_response2, document_list2) = get_search_results(:q => @all_docs_query, :page => page)
-      solr_response2.params[:start].to_i.should ==  blacklight_config[:default_solr_params][:rows] * (page-1)
+      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) = get_search_results(:q => @all_docs_query, :per_page => num_results, :page => page)
-      solr_response2a.params[:start].to_i.should == num_results * (page-1)
+      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) = get_search_results(:q => @all_docs_query, :rows => big, :page => big)
-      solr_response3.docs.size.should == document_list3.size
-      solr_response3.docs.size.should == 0
+      expect(solr_response3.docs.size).to eq(document_list3.size)
+      expect(solr_response3.docs.size).to eq(0)
     end
 
     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) = get_search_results(:q => @all_docs_query, :page => '-1')
-      solr_response4.params[:start].to_i.should == 0
+      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) = get_search_results(:q => @all_docs_query, :rows => big, :page => 1)
-      solr_response5.docs.size.should == document_list5.size
-      solr_response5.docs.size.should > 0
+      expect(solr_response5.docs.size).to eq(document_list5.size)
+      expect(solr_response5.docs.size).to be > 0
     end
 
   end # page specs
@@ -855,42 +867,42 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it "should raise Blacklight::InvalidSolrID for an unknown id" do
-      lambda {
+      expect {
         get_solr_response_for_doc_id(@bad_id)
-      }.should raise_error(Blacklight::Exceptions::InvalidSolrID)
+      }.to raise_error(Blacklight::Exceptions::InvalidSolrID)
     end
 
     it "should use a provided document request handler " do
-      blacklight_config.stub(:document_solr_request_handler => 'document')
-      blacklight_solr.should_receive(:get).with('select', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
-      lambda { get_solr_response_for_doc_id(@doc_id)}.should raise_error Blacklight::Exceptions::InvalidSolrID
+      allow(blacklight_config).to receive_messages(:document_solr_request_handler => 'document')
+      expect(blacklight_solr).to receive(:get).with('select', kind_of(Hash)).and_return({'response'=>{'docs'=>[]}})
+      expect { get_solr_response_for_doc_id(@doc_id)}.to raise_error Blacklight::Exceptions::InvalidSolrID
     end
 
     it "should have a non-nil result for a known id" do
-      @document.should_not == nil
+      expect(@document).not_to eq(nil)
     end
     it "should have a single document in the response for a known id" do
-      @response2.docs.size.should == 1
+      expect(@response2.docs.size).to eq(1)
     end
     it 'should have the expected value in the id field' do
-      @document.id.should == @doc_id
+      expect(@document.id).to eq(@doc_id)
     end
     it 'should have non-nil values for required fields set in initializer' do
-      @document.get(blacklight_config[:show][:html_title]).should_not == nil
-      @document.get(blacklight_config[:show][:heading]).should_not == nil
-      @document.get(blacklight_config[:show][:display_type]).should_not == nil
+      expect(@document.get(blacklight_config[:show][:html_title])).not_to eq(nil)
+      expect(@document.get(blacklight_config[:show][:heading])).not_to eq(nil)
+      expect(@document.get(blacklight_config[:show][:display_type])).not_to eq(nil)
     end
   end
 
   describe "solr_doc_params" do
     it "should default to using the 'document' requestHandler" do
       doc_params = solr_doc_params('asdfg')
-      doc_params[:qt].should == 'document'
+      expect(doc_params[:qt]).to eq('document')
     end
 
 
     describe "blacklight config's default_document_solr_parameters" do
-      def blacklight_config          
+      def blacklight_config
         config = Blacklight::Configuration.new
         config.default_document_solr_params = { :qt => 'my_custom_handler', :asdf => '1234' }
         config
@@ -898,15 +910,15 @@ describe 'Blacklight::SolrHelper' do
 
       it "should use parameters from the controller's default_document_solr_parameters" do
         doc_params = solr_doc_params('asdfg')
-        doc_params[:qt].should == 'my_custom_handler'
-        doc_params[:asdf].should == '1234'
+        expect(doc_params[:qt]).to eq('my_custom_handler')
+        expect(doc_params[:asdf]).to eq('1234')
       end
     end
 
   end
 
   describe "Get Document by custom unique id" do
-=begin    
+=begin
     # Can't test this properly without updating the "document" request handler in solr
     it "should respect the configuration-supplied unique id" do
       SolrDocument.should_receive(:unique_key).and_return("title_display")
@@ -917,7 +929,7 @@ describe 'Blacklight::SolrHelper' do
 =end
     it "should respect the configuration-supplied unique id" do
       doc_params = solr_doc_params('"Strong Medicine speaks"')
-      doc_params[:id].should == '"Strong Medicine speaks"'
+      expect(doc_params[:id]).to eq('"Strong Medicine speaks"')
     end
   end
 
@@ -946,18 +958,18 @@ describe 'Blacklight::SolrHelper' do
 =end
 
     it 'should have a doc id field' do
-      @doc[:id].should_not == nil
+      expect(@doc[:id]).not_to eq(nil)
     end
 
     it 'should have non-nil values for required fields set in initializer' do
-      @doc[blacklight_config.show.html_title].should_not == nil
-      @doc[blacklight_config.show.heading].should_not == nil
-      @doc[blacklight_config.show.display_type].should_not == nil
+      expect(@doc[blacklight_config.show.html_title]).not_to eq(nil)
+      expect(@doc[blacklight_config.show.heading]).not_to eq(nil)
+      expect(@doc[blacklight_config.show.display_type]).not_to eq(nil)
     end
 
     it "should limit search result by facets when supplied" do
       doc2 = get_single_doc_via_search(@doc_row , :q => @all_docs_query, :f => @multi_facets)
-      doc2[:id].should_not == nil
+      expect(doc2[:id]).not_to eq(nil)
     end
 
   end
@@ -966,15 +978,15 @@ describe 'Blacklight::SolrHelper' do
   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) = get_search_results({:q => 'boo'})
-      solr_response.spelling.words.should include('bon')
-      solr_response.spelling.words.should include('bod')  #for multiple suggestions
+      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) = get_search_results({:q => 'politica'})
-      solr_response.spelling.words.should include('policy') # less freq
-      solr_response.spelling.words.should include('politics') # more freq
-      solr_response.spelling.words.should include('political') # more freq
+      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
 =begin
       #  when we can have multiple suggestions
       solr_response.spelling.words.should_not include('policy') # less freq
@@ -985,39 +997,33 @@ describe 'Blacklight::SolrHelper' do
 
     it "title search results for just-poor-enough query term should have spelling suggestions" do
       (solr_response, document_list) = get_search_results({:q => 'yehudiyam', :qt => 'search', :"spellcheck.dictionary" => "title"})
-      solr_response.spelling.words.should include('yehudiyim')
+      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) = get_search_results({:q => 'shirma', :qt => 'search', :"spellcheck.dictionary" => "author"})
-      solr_response.spelling.words.should include('sharma')
+      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) = get_search_results({:q => 'wome', :qt => 'search', :"spellcheck.dictionary" => "subject"})
-      solr_response.spelling.words.should include('women')
+      expect(solr_response.spelling.words).to include('women')
     end
-
-    it 'search results for multiple terms query with just-poor-enough-terms should have spelling suggestions for each term' do
-     pending
-#     get_spelling_suggestion("histo politica").should_not be_nil
-    end
-
   end
 
   describe "facet_limit_for" do
 
     it "should return specified value for facet_field specified" do
-      facet_limit_for("subject_topic_facet").should == blacklight_config.facet_fields["subject_topic_facet"].limit
+      expect(facet_limit_for("subject_topic_facet")).to eq(blacklight_config.facet_fields["subject_topic_facet"].limit)
     end
     it "should generate proper solr param" do
-      solr_search_params[:"f.subject_topic_facet.facet.limit"].should == 21
+      expect(solr_search_params[:"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
       # facet_limit_hash has been removed from solrhelper in refactor. should it go back?
       pending "facet_limit_hash has been removed from solrhelper in refactor. should it go back?"
-      facet_limit_hash.should == blacklight_config[:facet][:limits]
+      expect(facet_limit_hash).to eq(blacklight_config[:facet][:limits])
     end
     it "should handle no facet_limits in config" do
       def blacklight_config
@@ -1025,61 +1031,61 @@ describe 'Blacklight::SolrHelper' do
         config.facet_fields = {}
         return config
       end
-            
-      facet_limit_for("subject_topic_facet").should be_nil
-      
-      solr_search_params.should_not have_key(:"f.subject_topic_facet.facet.limit")
-      
+
+      expect(facet_limit_for("subject_topic_facet")).to be_nil
+
+      expect(solr_search_params).not_to have_key(:"f.subject_topic_facet.facet.limit")
+
     end
-    
+
     describe "for 'true' configured values" do
       it "should return nil if no @response available" do
-        facet_limit_for("some_unknown_field").should be_nil
+        expect(facet_limit_for("some_unknown_field")).to be_nil
       end
-      it "should get from @response facet.limit if available" do        
+      it "should get from @response facet.limit if available" do
         # Okay, this is cheesy, since we included SolrHelper directly
         # into our example groups, we need to set an iVar here, so it will
-        # use it. 
-        @response = {"responseHeader" => {"params" => {"facet.limit" => 11}}}        
-        facet_limit_for("language_facet").should == 10
+        # use it.
+        @response = {"responseHeader" => {"params" => {"facet.limit" => 11}}}
+        expect(facet_limit_for("language_facet")).to eq(10)
       end
       it "should get from specific field in @response if available" do
         @response = {"responseHeader" => {"params" => {"facet.limit" => 11,"f.language_facet.facet.limit" => 16}}}
-        facet_limit_for("language_facet").should == 15
+        expect(facet_limit_for("language_facet")).to eq(15)
       end
     end
   end
 
     describe "with max per page enforced" do
-      def blacklight_config          
+      def blacklight_config
         config = Blacklight::Configuration.new
         config.max_per_page = 123
         return config
       end
 
       it "should enforce max_per_page against all parameters" do
-        blacklight_config.max_per_page.should == 123
-        solr_search_params(:per_page => 98765)[:rows].should == 123
-      end              
+        expect(blacklight_config.max_per_page).to eq(123)
+        expect(solr_search_params(:per_page => 98765)[:rows]).to eq(123)
+      end
     end
 
     describe "#get_solr_response_for_field_values" do
       before do
         @mock_response = double()
-        @mock_response.stub(:docs => [])
+        allow(@mock_response).to receive_messages(:docs => [])
       end
       it "should contruct a solr query based on the field and value pair" do
-        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(value)")).and_return(@mock_response)
+        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(value)")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', 'value')
       end
 
       it "should OR multiple values together" do
-        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
+        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(a OR b)")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', ['a', 'b'])
       end
 
       it "should escape crazy identifiers" do
-        self.should_receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
+        expect(self).to receive(:find).with(an_instance_of(String), hash_including(:q => "field_name:(\"h://\\\"\\\'\")")).and_return(@mock_response)
         get_solr_response_for_field_values('field_name', 'h://"\'')
       end
     end
@@ -1092,7 +1098,7 @@ describe 'Blacklight::SolrHelper' do
 #  more like this
 #  nearby on shelf
   it "should raise a Blacklight exception if RSolr can't connect to the Solr instance" do
-    blacklight_solr.stub(:get).and_raise(Errno::ECONNREFUSED)
+    allow(blacklight_solr).to receive(:get).and_raise(Errno::ECONNREFUSED)
     expect { find(:a => 123) }.to raise_exception(/Unable to connect to Solr instance/)
   end
 
@@ -1104,7 +1110,7 @@ describe 'Blacklight::SolrHelper' do
     it "should pull the grouped key out of the config" do
       blacklight_config.index.group = 'xyz'
       expect(self.grouped_key_for_results).to eq('xyz')
-    end 
+    end
   end
 
   describe "#with_tag_ex" do
@@ -1158,11 +1164,11 @@ describe 'Blacklight::SolrHelper' do
 
       it "defaults to get" do
         expect(blacklight_config.http_method).to eq :get
-        blacklight_solr.should_receive(:send_and_receive) do |path, params|
+        expect(blacklight_solr).to receive(:send_and_receive) { |path, params|
           expect(path).to eq 'select'
           expect(params[:method]).to eq :get
           expect(params[:params]).to include(:q)
-        end.and_return({'response'=>{'docs'=>[]}})
+        }.and_return({'response'=>{'docs'=>[]}})
         get_search_results(:q => @all_docs_query)
       end
     end
@@ -1172,11 +1178,11 @@ describe 'Blacklight::SolrHelper' do
 
       it "keep value set to post" do
         expect(blacklight_config.http_method).to eq :post
-        blacklight_solr.should_receive(:send_and_receive) do |path, params|
+        expect(blacklight_solr).to receive(:send_and_receive) { |path, params|
           expect(path).to eq 'select'
           expect(params[:method]).to eq :post
           expect(params[:data]).to include(:q)
-        end.and_return({'response'=>{'docs'=>[]}})
+        }.and_return({'response'=>{'docs'=>[]}})
         get_search_results(:q => @all_docs_query)
       end
 
@@ -1188,4 +1194,3 @@ describe 'Blacklight::SolrHelper' do
   end
 
 end
-