blacklight 5.0.0.pre1 → 5.0.0.pre2

data/spec/lib/{search_fields_spec.rb → blacklight/search_fields_spec.rb}

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe Blacklight::SearchFields do
 
@@ -26,12 +25,12 @@ describe Blacklight::SearchFields do
 
   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
 
   it "should fill in default qt where needed" do
-    @search_field_obj.search_field_def_for_key("all_fields").qt == @config.default_solr_params[:qt]
+    expect(@search_field_obj.search_field_def_for_key("all_fields").qt).to eq @config.default_solr_params[:qt]
   end
   
   it "should return proper options_for_select arguments" do
@@ -42,30 +41,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).to have(2).items
+       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 +72,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 { @bad_config.stub(: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 +84,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 { @bad_config.stub(: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/{blacklight_solr_document_dublin_core_spec.rb → blacklight/solr/document/dublin_core_spec.rb}

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe "Blacklight::Solr::Document::DublinCore" do
   before(:all) do
@@ -16,27 +15,27 @@ describe "Blacklight::Solr::Document::DublinCore" do
 
   it "should register all its export formats" do
     document = @mock_class.new
-    Set.new(document.export_formats.keys).should  be_superset(Set.new([:oai_dc_xml,:dc_xml, :xml]))    
+    expect(Set.new(document.export_formats.keys)).to be_superset(Set.new([:oai_dc_xml,:dc_xml, :xml]))    
   end
 
   it "should export oai_dc with the proper namespaces" do
     document = @mock_class.new
-    document.export_as_oai_dc_xml.should match 'xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"'
+    expect(document.export_as_oai_dc_xml).to match 'xmlns:oai_dc="http://www.openarchives.org/OAI/2.0/oai_dc/"'
 
   end
 
   it "should include 'dc:'-prefixed semantic fields" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       document = @mock_class.new(data)
-      document.export_as_oai_dc_xml.should match  'xmlns:dc="http://purl.org/dc/elements/1.1/"'
-      document.export_as_oai_dc_xml.should match  '<dc:title>654321</dc:title>'
+      expect(document.export_as_oai_dc_xml).to match  'xmlns:dc="http://purl.org/dc/elements/1.1/"'
+      expect(document.export_as_oai_dc_xml).to match  '<dc:title>654321</dc:title>'
   end
 
   it "should work with multi-value fields" do
       data = {'id'=>'123456','title_display'=>['654321', '987'] }
       document = @mock_class.new(data)
-      document.export_as_oai_dc_xml.should match '<dc:title>654321</dc:title>'
-      document.export_as_oai_dc_xml.should match '<dc:title>987</dc:title></oai_dc:dc>'
+      expect(document.export_as_oai_dc_xml).to match '<dc:title>654321</dc:title>'
+      expect(document.export_as_oai_dc_xml).to match '<dc:title>987</dc:title></oai_dc:dc>'
   end
 end
 

data/spec/lib/{blacklight_email_spec.rb → blacklight/solr/document/email_spec.rb}

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe "Blacklight::Solr::Document::Email" do
   before(:all) do
@@ -8,17 +7,17 @@ describe "Blacklight::Solr::Document::Email" do
   it "should only return values that are available in the field semantics" do
     doc = SolrDocument.new({:id=>"1234", :title_display=>"My Title"})
     email_body = doc.to_email_text
-    email_body.should match(/Title: My Title/)
-    email_body.should_not match(/Author/)
+    expect(email_body).to match(/Title: My Title/)
+    expect(email_body).to_not match(/Author/)
   end
   it "should handle multi-values fields correctly" do
     doc = SolrDocument.new({:id=>"1234", :title_display=>["My Title", "My Alt. Title"]})
     email_body = doc.to_email_text
-    email_body.should match(/Title: My Title My Alt. Title/)
+    expect(email_body).to match(/Title: My Title My Alt. Title/)
   end
   it "should return nil if there are no valid field semantics to build the email body from" do
     doc = SolrDocument.new({:id=>"1234"})
-    doc.to_email_text.should be_nil
+    expect(doc.to_email_text).to be_nil
   end
 end
 

data/spec/lib/{blacklight_solr_document_more_like_this_spec.rb → blacklight/solr/document/more_like_this_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe Blacklight::Solr::Document::MoreLikeThis do
   before(:all) do
@@ -10,9 +10,9 @@ describe Blacklight::Solr::Document::MoreLikeThis do
   it "should pluck the MoreLikeThis results from the Solr Response" do
     mock_solr_response = double(:more_like => [{'id' => 'abc'}])
     result = @mock_class.new({:id => '123'}, mock_solr_response).more_like_this
-    result.should have(1).item
-    result.first.should be_a_kind_of(SolrDocument)
-    result.first.id.should == 'abc'
-    result.first.solr_response.should == mock_solr_response
+    expect(result).to have(1).item
+    expect(result.first).to be_a_kind_of(SolrDocument)
+    expect(result.first.id).to eq 'abc'
+    expect(result.first.solr_response).to eq mock_solr_response
   end 
 end

data/spec/lib/{blacklight_sms_spec.rb → blacklight/solr/document/sms_spec.rb}

@@ -1,5 +1,4 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe "Blacklight::Solr::Document::Email" do
   before(:all) do
@@ -8,17 +7,17 @@ describe "Blacklight::Solr::Document::Email" do
   it "should only return values that are available in the field semantics" do
     doc = SolrDocument.new({:id=>"1234", :title_display=>"My Title", :author_display=>"Joe Schmoe"})
     sms_text = doc.to_sms_text
-    sms_text.should match(/My Title by Joe Schmoe/)
+    expect(sms_text).to match(/My Title by Joe Schmoe/)
   end
   it "should handle multi-values fields correctly and only take the first" do
     doc = SolrDocument.new({:id=>"1234", :title_display=>["My Title", "My Alt. Title"]})
     sms_text = doc.to_sms_text
-    sms_text.should match(/My Title/)
-    sms_text.should_not match(/My Alt\. Title/)
+    expect(sms_text).to match(/My Title/)
+    expect(sms_text).to_not match(/My Alt\. Title/)
   end
   it "should return nil if there are no valid field semantics to build the email body from" do
     doc = SolrDocument.new({:id=>"1234"})
-    doc.to_sms_text.should be_nil
+    expect(doc.to_sms_text).to be_nil
   end
 end
 

data/spec/lib/{blacklight_solr_document_spec.rb → blacklight/solr/document_spec.rb}

@@ -1,6 +1,4 @@
-# -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'rubygems'
+require 'spec_helper'
 
 describe "Blacklight::Solr::Document" do
     class MockDocument
@@ -23,13 +21,13 @@ describe "Blacklight::Solr::Document" do
       it 'should create a doc with hashy methods' do
         doc = SolrDocument.new({'id'=>'SP2514N','inStock'=>true,'manu'=>'Samsung Electronics Co. Ltd.','name'=>'Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133','popularity'=>6,'price'=>92.0,'sku'=>'SP2514N','timestamp'=>'2009-03-20T14:42:49.795Z','cat'=>['electronics','hard drive'],'spell'=>['Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133'],'features'=>['7200RPM, 8MB cache, IDE Ultra ATA-133','NoiseGuard, SilentSeek technology, Fluid Dynamic Bearing (FDB) motor']})
 
-        doc.has?(:cat, /^elec/).should == true
-        doc.has?(:cat, 'elec').should_not == true
-        doc.has?(:cat, 'electronics').should == true
+        expect(doc.has?(:cat, /^elec/)).to eq true
+        expect(doc.has?(:cat, 'elec')).not_to eq true
+        expect(doc.has?(:cat, 'electronics')).to eq true
 
-        doc.get(:cat).should == 'electronics, hard drive'
-        doc.get(:xyz).should == nil
-        doc.get(:xyz, :default=>'def').should == 'def'
+        expect(doc.get(:cat)).to eq 'electronics, hard drive'
+        expect(doc.get(:xyz)).to be_nil
+        expect(doc.get(:xyz, :default=>'def')).to eq 'def'
       end
     end
 
@@ -44,7 +42,7 @@ describe "Blacklight::Solr::Document" do
       end
       it "should use a configuration-defined document unique key" do
         @document = MockDocument.new :id => 'asdf', :my_unique_key => '1234'
-        @document.id.should == '1234'
+        expect(@document.id).to eq '1234'
       end
     end
 
@@ -57,54 +55,54 @@ describe "Blacklight::Solr::Document" do
       it "should let you register an extension" do
         MockDocument.use_extension(MockExtension) { |doc| true }
 
-        MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}.should_not be_nil
+        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
       end
       it "should let you register an extension with a nil condition proc" do
         MockDocument.use_extension(MockExtension) { |doc| true }
-        MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}.should_not be_nil
+        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
       end
       it "should apply an extension whose condition is met" do
         MockDocument.use_extension(MockExtension) {|doc| true}
         doc = MockDocument.new()
 
-        doc.methods.find {|name| name.to_s == "my_extension_method"}.should_not be_nil
-        doc.my_extension_method.to_s.should == "my_extension_results"
+        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).not_to be_nil
+        expect(doc.my_extension_method.to_s).to eq "my_extension_results"
       end
       it "should apply an extension based on a Solr field" do
         MockDocument.use_extension(MockExtension) {|doc| doc.key?(:required_key)}
 
         with_extension = MockDocument.new(:required_key => "value")
-        with_extension.my_extension_method.to_s.should == "my_extension_results"
+        expect(with_extension.my_extension_method.to_s).to eq "my_extension_results"
 
         without_extension = MockDocument.new(:other_key => "value")
-        without_extension.methods.find {|name| name.to_s == "my_extension_method"}.should be_nil
+        expect(without_extension.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil
         
       end
       it "should not apply an extension whose condition is not met" do
         MockDocument.use_extension(MockExtension) {|doc| false}
         doc = MockDocument.new()
   
-        doc.methods.find {|name| name.to_s == "my_extension_method"}.should be_nil      
+        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil      
       end
       it "should treat a nil condition as always applyable" do
         MockDocument.use_extension(MockExtension)
   
         doc = MockDocument.new()
   
-        doc.methods.find {|name | name.to_s =="my_extension_method"}.should_not be_nil
-        doc.my_extension_method.should == "my_extension_results"
+        expect(doc.methods.find {|name | name.to_s =="my_extension_method"}).not_to be_nil
+        expect(doc.my_extension_method).to eq "my_extension_results"
       end
       it "should let last extension applied override earlier extensions" do
         MockDocument.use_extension(MockExtension)
         MockDocument.use_extension(MockSecondExtension)
 
-        MockDocument.new().my_extension_method.to_s.should == "override"        
+        expect(MockDocument.new().my_extension_method.to_s).to eq "override"        
       end
 
       describe "extension_parameters class-level hash" do
         it "should provide an extension_parameters hash at the class level" do
           MockDocument.extension_parameters[:key] = "value"
-          MockDocument.extension_parameters[:key].should == "value"
+          expect(MockDocument.extension_parameters[:key]).to eq "value"
         end
     
         it "extension_parameters should not be shared between classes" do
@@ -118,7 +116,7 @@ describe "Blacklight::Solr::Document" do
           class_one.extension_parameters[:key] = "class_one_value"
           class_two.extension_parameters[:key] = "class_two_value"
 
-          class_one.extension_parameters[:key].should == "class_one_value"
+          expect(class_one.extension_parameters[:key]).to eq "class_one_value"
         end
       end
       
@@ -136,14 +134,14 @@ describe "Blacklight::Solr::Document" do
       it "reports it's exportable formats properly" do
         doc = MockDocument.new
         doc.will_export_as(:marc, "application/marc" )
-        doc.export_formats.should have_key(:marc)
-        doc.export_formats[:marc][:content_type].should ==  "application/marc"
+        expect(doc.export_formats).to have_key(:marc)
+        expect(doc.export_formats[:marc][:content_type]).to eq "application/marc"
       end
 
       it "looks up content-type from Mime::Type if not given in arg" do
         doc = MockDocument.new
         doc.will_export_as(:html)
-        doc.export_formats.should have_key(:html)        
+        expect(doc.export_formats).to have_key(:html)        
       end
 
       context "format not registered with Mime::Type" do
@@ -154,17 +152,17 @@ describe "Blacklight::Solr::Document" do
           # registration in an after, sorry. 
         end
         it "registers format" do
-          defined?("Mime::MOCK2").should be_true
+          expect(defined?("Mime::MOCK2")).to be_true
         end
         it "registers as alias only" do
-          Mime::Type.lookup("application/mock2").should_not equal(Mime::Type.lookup_by_extension("mock2"))
+          expect(Mime::Type.lookup("application/mock2")).not_to equal Mime::Type.lookup_by_extension("mock2")
         end
       end
 
       it "export_as(:format) by calling export_as_format" do
         doc = MockDocument.new
         doc.will_export_as(:marc, "application/marc")
-        doc.export_as(:marc).should == "fake_marc"
+        expect(doc.export_as(:marc)).to eq "fake_marc"
       end
     end
 
@@ -183,17 +181,17 @@ describe "Blacklight::Solr::Document" do
       end
 
       it "should return complete dictionary based on config'd fields" do        
-        @doc1.to_semantic_values.should == {:title => ["doc1 title"], :something => ["val1", "val2"]}
+        expect(@doc1.to_semantic_values).to eq :title => ["doc1 title"], :something => ["val1", "val2"]
       end      
       it "should return empty array for a key without a value" do
-        @doc1.to_semantic_values[:author].should == []
-        @doc1.to_semantic_values[:nonexistent_token].should == []
+        expect(@doc1.to_semantic_values[:author]).to be_empty
+        expect(@doc1.to_semantic_values[:nonexistent_token]).to be_empty
       end
       it "should return an array even for a single-value field" do
-        @doc1.to_semantic_values[:title].should be_kind_of(Array)
+        expect(@doc1.to_semantic_values[:title]).to be_kind_of(Array)
       end
       it "should return complete array for a multi-value field" do
-        @doc1.to_semantic_values[:something].should == ["val1", "val2"] 
+        expect(@doc1.to_semantic_values[:something]).to eq ["val1", "val2"] 
       end
       
     end
@@ -207,27 +205,27 @@ describe "Blacklight::Solr::Document" do
 
       describe "#has_highlight_field?" do
         it "should be true if the highlight field is in the solr response" do
-          @document.should have_highlight_field 'title_text'
-          @document.should have_highlight_field :title_text
+          expect(@document).to have_highlight_field 'title_text'
+          expect(@document).to have_highlight_field :title_text
         end
 
         it "should be false if the highlight field isn't in the solr response" do
-           @document.should_not have_highlight_field 'nonexisting_field'
+           expect(@document).to_not have_highlight_field 'nonexisting_field'
         end
       end
 
       describe "#highlight_field" do
         it "should return a value" do
-          @document.highlight_field('title_text').should include('doc <em>1</em>')
+          expect(@document.highlight_field('title_text')).to include('doc <em>1</em>')
         end
 
 
         it "should return a value that is html safe" do
-          @document.highlight_field('title_text').first.should be_html_safe
+          expect(@document.highlight_field('title_text').first).to be_html_safe
         end
 
         it "should return nil when the field doesn't exist" do
-          @document.highlight_field('nonexisting_field').should be_nil
+          expect(@document.highlight_field('nonexisting_field')).to be_nil
         end
       end
     end

data/spec/lib/{solr_helper_spec.rb → blacklight/solr_helper_spec.rb}

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 # check the methods that do solr requests. Note that we are not testing if
 #  solr gives "correct" responses, as that's out of scope (it's a part of
@@ -59,7 +59,7 @@ describe 'Blacklight::SolrHelper' do
         self.solr_search_params_logic += [:add_foo_to_solr_params]
         
         
-        self.solr_search_params[:wt].should == "TESTING"                
+        expect(self.solr_search_params[:wt]).to eq "TESTING"                
     end
     
     
@@ -71,23 +71,23 @@ 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
 
@@ -95,16 +95,16 @@ describe 'Blacklight::SolrHelper' 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 value for the key 'q' regardless if a symbol or string" do        
         solr_params = solr_search_params( :q => "some query", 'q' => 'another value' )
-        solr_params[:q].should == 'some query'
-        solr_params['q'].should == 'some query'
+        expect(solr_params[:q]).to eq 'some query'
+        expect(solr_params['q']).to eq 'some query'
       end
     end
 
@@ -114,11 +114,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
@@ -131,7 +131,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
 
@@ -146,10 +146,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
 
@@ -160,48 +160,48 @@ 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))
 
-        facet_value_to_fq_string("facet_name", "2012-01-01").should  == "facet_name:2012-01-01"
+        expect(facet_value_to_fq_string("facet_name", "2012-01-01")).to eq "facet_name:2012-01-01"
       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))
 
-        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
 
@@ -209,31 +209,31 @@ describe 'Blacklight::SolrHelper' do
       let(:solr_params) { solr_search_params @subject_search_params }
 
       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.to_hash.tap do |h|
-          h[:phrase_filters].should be_nil
-          h[:fq].should be_nil
-          h[:commit].should be_nil
-          h[:action].should be_nil
-          h[:controller].should be_nil
+          expect(h[:phrase_filters]).to be_nil
+          expect(h[:fq]).to be_nil
+          expect(h[:commit]).to be_nil
+          expect(h[:action]).to be_nil
+          expect(h[:controller]).to be_nil
         end
       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 )
@@ -242,8 +242,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
 
@@ -253,7 +253,7 @@ describe 'Blacklight::SolrHelper' do
           super.merge(:qt => "overridden")
         end
         
-        solr_search_params[:qt].should == "overridden"        
+        expect(solr_search_params[:qt]).to eq "overridden"        
       end
     end
 
@@ -263,7 +263,7 @@ describe 'Blacklight::SolrHelper' do
         
         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
 
@@ -288,8 +288,8 @@ describe 'Blacklight::SolrHelper' do
 
         expect(solr_parameters[:facet]).to be_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
@@ -297,8 +297,8 @@ 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
 
@@ -319,11 +319,11 @@ describe 'Blacklight::SolrHelper' do
       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
@@ -333,23 +333,23 @@ 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
@@ -358,7 +358,7 @@ describe 'Blacklight::SolrHelper' do
     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'        
+        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
@@ -369,12 +369,12 @@ describe 'Blacklight::SolrHelper' do
         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
 
@@ -408,35 +408,35 @@ describe 'Blacklight::SolrHelper' do
       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"]).to have_at_least(2).fields
       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"]).to have_at_least(3).fields
       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"]).to have_at_least(3).fields
       end
     end
 
@@ -458,21 +458,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
@@ -481,29 +481,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'}}
@@ -515,7 +515,7 @@ describe 'Blacklight::SolrHelper' do
         # don't care about.
         next if ['facets', "facet.field", '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
@@ -531,11 +531,11 @@ describe 'Blacklight::SolrHelper' do
     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
   
@@ -544,10 +544,10 @@ describe 'Blacklight::SolrHelper' 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
 
@@ -563,16 +563,16 @@ describe 'Blacklight::SolrHelper' do
       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")
+          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")
         end.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).to have(@document_list.length).docs
       end
 
       it 'should have @response.docs list representing same documents as SolrDocuments in @document_list' do
@@ -580,10 +580,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
@@ -626,7 +626,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).to have_at_least(1).result
       end
 
     end
@@ -636,8 +636,8 @@ 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 be_nil
+        expect(document.get(blacklight_config.index.record_display_type)).not_to be_nil
       end
     end
 
@@ -647,13 +647,13 @@ describe 'Blacklight::SolrHelper' do
     	
       it 'should have results' do
         solr_response = query_solr(:q => @single_word_query)
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs).to have_at_least(1).result
       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).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
@@ -661,48 +661,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).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
     describe "One Facet, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @single_facet)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
     describe "Mult Facets, No Query" do
       it 'should have results' do
         (solr_response, document_list) = get_search_results(:f => @multi_facets)
-        solr_response.docs.size.should == document_list.size
-        solr_response.docs.size.should > 0
+        expect(solr_response.docs).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
     describe "Single Word Query with One Facet" do
       it 'should have results' do
         (solr_response, document_list) = 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).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
     describe "Multiple Words Query with Multiple Facets" do
       it 'should have results' do
         (solr_response, document_list) = 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).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       end
     end
 
     describe "for All Docs Query and One Facet" do
       it 'should have results' do
         (solr_response, document_list) = 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).to have(document_list.size).results
+        expect(solr_response.docs).to have_at_least(1).result
       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)
@@ -711,24 +711,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(document_list).to have(0).results
+        expect(solr_response.docs).to have(0).results
       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(document_list).to have(0).results
+        expect(solr_response.docs).to have(0).results
       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(document_list).to have(0).results
+        expect(solr_response.docs).to have(0).results
       end
     end
 
@@ -747,16 +747,16 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it 'should have more than one facet' do
-      @facets.size.should > 1
+      expect(@facets).to have_at_least(1).facet
     end
     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).to have_at_least(1).hit
       end
     end
     it 'should have multiple values for at least one facet' do
@@ -767,12 +767,12 @@ 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|
         facet.items.each do |facet_vals|
-          facet_vals.hits > 0
+          expect(facet_vals.hits).to be > 0
         end
       end
     end
@@ -784,58 +784,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).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) = 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(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) = 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(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) = 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(document_list3).to have(0).docs
+      expect(solr_response3.docs).to have(0).docs
     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).to have(document_list5.length).docs
+      expect(solr_response5.docs).to have_at_least(1).doc
     end
 
   end # page specs
@@ -849,37 +849,37 @@ 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
+      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 be_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 be_nil
+      expect(@document.get(blacklight_config[:show][:heading])).not_to be_nil
+      expect(@document.get(blacklight_config[:show][:display_type])).not_to be_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
 
 
@@ -892,8 +892,8 @@ 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
 
@@ -905,13 +905,13 @@ describe 'Blacklight::SolrHelper' do
     it "should respect the configuration-supplied unique id" do
       SolrDocument.should_receive(:unique_key).and_return("title_display")
       @response, @document = @solr_helper.get_solr_response_for_doc_id('"Strong Medicine speaks"')
-      @document.id.should == '"Strong Medicine speaks"'
-      @document.get(:id).should == 2007020969
+      @document.id).to eq '"Strong Medicine speaks"'
+      @document.get(:id)).to eq 2007020969
     end
 =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
 
@@ -926,7 +926,7 @@ describe 'Blacklight::SolrHelper' do
 =begin
 # can't test these here, because the method only returns the document
     it "should get a single document" do
-      response.docs.size.should == 1
+      response.docs.size).to eq 1
     end
 
     doc2 = get_single_doc_via_search(@all_docs_query, nil, @doc_row, @multi_facets)
@@ -935,23 +935,23 @@ describe 'Blacklight::SolrHelper' do
     end
 
     it "should not have facets in the response" do
-      response.facets.size.should == 0
+      response.facets.size).to eq 0
     end
 =end
 
     it 'should have a doc id field' do
-      @doc[:id].should_not == nil
+      expect(@doc[:id]).not_to be_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 be_nil
+      expect(@doc[blacklight_config.show.heading]).not_to be_nil
+      expect(@doc[blacklight_config.show.display_type]).not_to be_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 be_nil
     end
 
   end
@@ -960,36 +960,36 @@ 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
-      solr_response.spelling.words.should include('politics') # more freq
-      solr_response.spelling.words.should include('political') # more freq
+      solr_response.spelling.words).to include('politics') # more freq
+      solr_response.spelling.words).to include('political') # more freq
 =end
     end
 
     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
@@ -1002,16 +1002,16 @@ describe 'Blacklight::SolrHelper' do
   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
@@ -1020,26 +1020,26 @@ describe 'Blacklight::SolrHelper' do
         return config
       end
             
-      facet_limit_for("subject_topic_facet").should be_nil
+      expect(facet_limit_for("subject_topic_facet")).to be_nil
       
-      solr_search_params.should_not have_key(:"f.subject_topic_facet.facet.limit")
+      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        
         # 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
+        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
@@ -1052,8 +1052,8 @@ describe 'Blacklight::SolrHelper' do
       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
+        expect(blacklight_config.max_per_page).to eq 123
+        expect(solr_search_params(:per_page => 98765)[:rows]).to eq 123
       end              
     end
 
@@ -1129,14 +1129,14 @@ describe 'Blacklight::SolrHelper' do
     it "should return only the next document if the counter is 0" do
       response, docs = get_previous_and_next_documents_for_search(0, :q => '')
 
-      expect(docs.first).to eq nil
+      expect(docs.first).to be_nil
       expect(docs.last.id).to eq @all_docs[1].id
     end
 
     it "should return only the previous document if the counter is the total number of documents" do
       response, docs = get_previous_and_next_documents_for_search(@full_response.total - 1, :q => '')
       expect(docs.first.id).to eq @all_docs.slice(-2).id
-      expect(docs.last).to eq nil
+      expect(docs.last).to be_nil
     end
 
     it "should return an array of nil values if there is only one result" do