blacklight 4.7.0 → 4.8.0

data/spec/controllers/bookmarks_controller_spec.rb

@@ -8,34 +8,34 @@ describe BookmarksController do
   describe "update" do
     it "has a 204 status code when creating a new one" do
       xhr :put, :update, :id => '2007020969', :format => :js
-      response.should be_success
-      response.code.should == "204"
+      expect(response).to be_success
+      expect(response.code).to eq("204")
     end
     
     it "has a 500 status code when fails is success" do
-      @controller.stub_chain(:current_or_guest_user, :existing_bookmark_for).and_return(false)
-      @controller.stub_chain(:current_or_guest_user, :persisted?).and_return(true)
-      @controller.stub_chain(:current_or_guest_user, :bookmarks, :create).and_return(false)  
+      allow(@controller).to receive_message_chain(:current_or_guest_user, :existing_bookmark_for).and_return(false)
+      allow(@controller).to receive_message_chain(:current_or_guest_user, :persisted?).and_return(true)
+      allow(@controller).to receive_message_chain(:current_or_guest_user, :bookmarks, :create).and_return(false)  
       xhr :put, :update, :id => 'iamabooboo', :format => :js
-      response.code.should == "500"
+      expect(response.code).to eq("500")
     end
   end
   
   describe "delete" do
     it "has a 204 status code when delete is success" do
       xhr :delete, :destroy, :id => '2007020969', :format => :js
-      response.should be_success
-      response.code.should == "204"
+      expect(response).to be_success
+      expect(response.code).to eq("204")
     end
 
    it "has a 500 status code when delete is not success" do
       bm = double(Bookmark)
-      @controller.stub_chain(:current_or_guest_user, :existing_bookmark_for).and_return(bm)
-      @controller.stub_chain(:current_or_guest_user, :bookmarks, :delete).and_return(false)
+      allow(@controller).to receive_message_chain(:current_or_guest_user, :existing_bookmark_for).and_return(bm)
+      allow(@controller).to receive_message_chain(:current_or_guest_user, :bookmarks, :delete).and_return(false)
      
       xhr :delete, :destroy, :id => 'pleasekillme', :format => :js
      #
-      response.code.should == "500"
+      expect(response.code).to eq("500")
     end
   end
   

data/spec/controllers/catalog_controller_spec.rb

@@ -23,68 +23,68 @@ describe CatalogController do
     
     describe "with format :html" do
       it "should have no search history if no search criteria" do
-        controller.should_receive(:get_search_results) 
+        expect(controller).to receive(:get_search_results) 
         session[:history] = []
         get :index
-        session[:history].length.should == 0
+        expect(session[:history].length).to eq(0)
       end
 
       # check each user manipulated parameter
       it "should have docs and facets for query with results", :integration => true do
         get :index, :q => @user_query
-        assigns_response.docs.size.should > 1
+        expect(assigns_response.docs.size).to be > 1
         assert_facets_have_values(assigns_response.facets)
       end
       it "should have docs and facets for existing facet value", :integration => true do
         get :index, :f => @facet_query
-        assigns_response.docs.size.should > 1
+        expect(assigns_response.docs.size).to be > 1
         assert_facets_have_values(assigns_response.facets)
       end
       it "should have docs and facets for non-default results per page", :integration => true do
         num_per_page = 7
         get :index, :per_page => num_per_page
-        assigns_response.docs.size.should == num_per_page
+        expect(assigns_response.docs.size).to eq(num_per_page)
         assert_facets_have_values(assigns_response.facets)
       end
 
       it "should have docs and facets for second page", :integration => true do
         page = 2
         get :index, :page => page
-        assigns_response.docs.size.should > 1
-        assigns_response.params[:start].to_i.should == (page-1) * @controller.blacklight_config[:default_solr_params][:rows]
+        expect(assigns_response.docs.size).to be > 1
+        expect(assigns_response.params[:start].to_i).to eq((page-1) * @controller.blacklight_config[:default_solr_params][:rows])
         assert_facets_have_values(assigns_response.facets)
       end
 
       it "should have no docs or facet values for query without results", :integration => true do
         get :index, :q => @no_docs_query
 
-        assigns_response.docs.size.should == 0
+        expect(assigns_response.docs.size).to eq(0)
         assigns_response.facets.each do |facet|
-          facet.items.size.should == 0
+          expect(facet.items.size).to eq(0)
         end
       end
 
       it "should have a spelling suggestion for an appropriately poor query", :integration => true do
         get :index, :q => 'boo'
-        assigns_response.spelling.words.should_not be_nil
+        expect(assigns_response.spelling.words).not_to be_nil
       end
 
       describe "session" do
         before do
-          controller.stub(:get_search_results) 
+          allow(controller).to receive(:get_search_results) 
         end
         it "should include :search key with hash" do
           get :index
-          session[:search].should_not be_nil
-          session[:search].should be_kind_of(Hash)
+          expect(session[:search]).not_to be_nil
+          expect(session[:search]).to be_kind_of(Hash)
         end
         it "should include search hash with key :q" do
           get :index, :q => @user_query
-          session[:search].should_not be_nil
-          session[:search].keys.should include(:id)
+          expect(session[:search]).not_to be_nil
+          expect(session[:search].keys).to include('id')
           
-          search = Search.find(session[:search][:id])
-          expect(search.query_params[:q]).to eq @user_query
+          search = Search.find(session[:search]['id'])
+          expect(search.query_params['q']).to eq @user_query
         end
       end
 
@@ -92,7 +92,7 @@ describe CatalogController do
       describe "for default query" do
         it "should get documents when no query", :integration => true do
           get :index
-          assigns_response.docs.size.should > 1
+          expect(assigns_response.docs.size).to be > 1
         end
         it "should get facets when no query", :integration => true do
           get :index
@@ -101,29 +101,29 @@ describe CatalogController do
       end
 
       it "should render index.html.erb" do
-        controller.stub(:get_search_results)
+        allow(controller).to receive(:get_search_results)
         get :index
-        response.should render_template(:index)
+        expect(response).to render_template(:index)
       end
 
       # NOTE: status code is always 200 in isolation mode ...
       it "HTTP status code for GET should be 200", :integration => true do
         get :index
-        response.should be_success
+        expect(response).to be_success
       end
     end
 
     describe "with format :rss" do
       it "should get the feed", :integration => true do
         get :index, :format => 'rss'
-        response.should be_success
+        expect(response).to be_success
       end
     end
 
     describe "with format :json" do
       before do
         get :index, :format => 'json'
-        response.should be_success
+        expect(response).to be_success
       end
       let(:json) { JSON.parse(response.body)['response'] }
       let(:pages) { json["pages"] }
@@ -131,29 +131,29 @@ describe CatalogController do
       let(:facets) { json["facets"] }
 
       it "should get the pages" do
-        pages["total_count"].should == 30 
-        pages["current_page"].should == 1
-        pages["total_pages"].should == 3
+        expect(pages["total_count"]).to eq(30) 
+        expect(pages["current_page"]).to eq(1)
+        expect(pages["total_pages"]).to eq(3)
       end
 
       it "should get the documents" do
-        docs.size.should == 10
+        expect(docs.size).to eq(10)
         expect(docs.first.keys).to match_array(["published_display", "author_display", "lc_callnum_display", "pub_date", "subtitle_display", "format", "material_type_display", "title_display", "id", "subject_topic_facet", "language_facet", "score"])
       end
 
       it "should get the facets" do
-        facets.length.should == 9
-        facets.first.should == {"name"=>"format", "label" => "Format", "items"=>[{"value"=>"Book", "hits"=>30, "label"=>"Book"}]}
+        expect(facets.length).to eq(9)
+        expect(facets.first).to eq({"name"=>"format", "label" => "Format", "items"=>[{"value"=>"Book", "hits"=>30, "label"=>"Book"}]})
       end
 
       describe "facets" do
         let(:query_facet_items) { facets.last['items'] }
         let(:regular_facet_items) { facets.first['items'] }
         it "should have items with labels and values" do
-          query_facet_items.first['label'].should == 'within 10 Years'
-          query_facet_items.first['value'].should == 'years_10'
-          regular_facet_items.first['label'].should == "Book"
-          regular_facet_items.first['value'].should == "Book"
+          expect(query_facet_items.first['label']).to eq('within 10 Years')
+          expect(query_facet_items.first['value']).to eq('years_10')
+          expect(regular_facet_items.first['label']).to eq("Book")
+          expect(regular_facet_items.first['value']).to eq("Book")
         end
       end
     end
@@ -165,7 +165,7 @@ describe CatalogController do
 
     it "should set counter value into session[:search]" do
       put :update, :id => doc_id, :counter => 3
-      session[:search][:counter].should == "3"
+      expect(session[:search]['counter']).to eq("3")
     end
 
     it "should redirect to show action for doc id" do
@@ -182,14 +182,14 @@ describe CatalogController do
     describe "with format :html" do
       it "should get document", :integration => true do
         get :show, :id => doc_id
-        assigns[:document].should_not be_nil
+        expect(assigns[:document]).not_to be_nil
       end
     end
 
     describe "with format :json" do
       it "should get the feed" do
         get :show, id: doc_id, format: 'json'
-        response.should be_success
+        expect(response).to be_success
         json = JSON.parse response.body
         expect(json["response"]["document"].keys).to match_array(["author_t", "opensearch_display", "marc_display", "published_display", "author_display", "lc_callnum_display", "title_t", "pub_date", "pub_date_sort", "subtitle_display", "format", "url_suppl_display", "material_type_display", "title_display", "subject_addl_t", "subject_t", "isbn_t", "id", "title_addl_t", "subject_geo_facet", "subject_topic_facet", "author_addl_t", "language_facet", "subtitle_t", "timestamp"])
       end
@@ -199,59 +199,59 @@ describe CatalogController do
       before do
         @mock_response = double()
         @mock_document = double()
-        @mock_document.stub(:export_formats => {})
-        controller.stub(:get_solr_response_for_doc_id => [@mock_response, @mock_document], 
+        allow(@mock_document).to receive_messages(:export_formats => {})
+        allow(controller).to receive_messages(:get_solr_response_for_doc_id => [@mock_response, @mock_document], 
                         :get_previous_and_next_documents_for_search => [double(:total => 5), [double("a"), @mock_document, double("b")]])
 
         current_search = Search.create(:query_params => { :q => ""})
-        controller.stub(:current_search_session => current_search)
+        allow(controller).to receive_messages(:current_search_session => current_search)
 
         @search_session = { :id => current_search.id }
       end
     it "should set previous document if counter present in session" do
-      session[:search] = @search_session.merge(:counter => 2)
+      session[:search] = @search_session.merge('counter' => 2)
       get :show, :id => doc_id
-      assigns[:previous_document].should_not be_nil
+      expect(assigns[:previous_document]).not_to be_nil
     end
     it "should not set previous or next document if session is blank" do
       get :show, :id => doc_id
-      assigns[:previous_document].should be_nil
-      assigns[:next_document].should be_nil
+      expect(assigns[:previous_document]).to be_nil
+      expect(assigns[:next_document]).to be_nil
     end
-    it "should not set previous or next document if session[:search][:counter] is nil" do
+    it "should not set previous or next document if session[:search]['counter'] is nil" do
       session[:search] = {}
       get :show, :id => doc_id
-      assigns[:previous_document].should be_nil
-      assigns[:next_document].should be_nil
+      expect(assigns[:previous_document]).to be_nil
+      expect(assigns[:next_document]).to be_nil
     end
     it "should set next document if counter present in session" do
-      session[:search] = @search_session.merge(:counter => 2)
+      session[:search] = @search_session.merge('counter' => 2)
       get :show, :id => doc_id
-      assigns[:next_document].should_not be_nil
+      expect(assigns[:next_document]).not_to be_nil
     end
     end
 
     # NOTE: status code is always 200 in isolation mode ...
     it "HTTP status code for GET should be 200", :integration => true do
       get :show, :id => doc_id
-      response.should be_success
+      expect(response).to be_success
     end
     it "should render show.html.erb" do
       @mock_response = double()
       @mock_document = double()
-      @mock_document.stub(:export_formats => {})
-      controller.stub(:get_solr_response_for_doc_id => [@mock_response, @mock_document], 
+      allow(@mock_document).to receive_messages(:export_formats => {})
+      allow(controller).to receive_messages(:get_solr_response_for_doc_id => [@mock_response, @mock_document], 
                       :get_single_doc_via_search => @mock_document)
       get :show, :id => doc_id
-      response.should render_template(:show)
+      expect(response).to render_template(:show)
     end
 
     describe "@document" do
       before do
         @mock_response = double()
-        @mock_response.stub(:docs => [{ :id => 'my_fake_doc' }])
+        allow(@mock_response).to receive_messages(:docs => [{ :id => 'my_fake_doc' }])
         @mock_document = double()
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
       end
       before(:each) do
@@ -259,7 +259,7 @@ describe CatalogController do
         @document = assigns[:document]
       end
       it "should be a SolrDocument" do
-        @document.should be_instance_of(SolrDocument)
+        expect(@document).to be_instance_of(SolrDocument)
       end
     end
     
@@ -276,12 +276,12 @@ describe CatalogController do
       end
       before do
         @mock_response = double()
-        @mock_response.stub(:docs => [{ :id => 'my_fake_doc' }])
+        allow(@mock_response).to receive_messages(:docs => [{ :id => 'my_fake_doc' }])
         @mock_document = double()
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
 
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
       end
 
@@ -299,8 +299,8 @@ describe CatalogController do
       
       it "should respond to an extension-registered format properly" do
         get :show, :id => doc_id, :format => "mock" # This no longer works: :format => "mock"
-        response.should be_success
-        response.body.should =~ /mock_export/
+        expect(response).to be_success
+        expect(response.body).to match(/mock_export/)
       end
       
 
@@ -316,18 +316,18 @@ describe CatalogController do
     before do
       @mock_response = double()
       @mock_document = double()
-      @mock_response.stub(:docs => [{ :id => 'my_fake_doc' }, { :id => 'my_other_doc'}])
+      allow(@mock_response).to receive_messages(:docs => [{ :id => 'my_fake_doc' }, { :id => 'my_other_doc'}])
       @mock_document = double()
-      controller.stub(:find => @mock_response, 
+      allow(controller).to receive_messages(:find => @mock_response, 
                       :get_single_doc_via_search => @mock_document)
     end
     it "should return an opensearch description" do
       get :opensearch, :format => 'xml'
-      response.should be_success
+      expect(response).to be_success
     end
     it "should return valid JSON" do
       get :opensearch,:format => 'json', :q => "a"
-      response.should be_success
+      expect(response).to be_success
     end
   end
 #=end
@@ -336,9 +336,9 @@ describe CatalogController do
       before do
         @mock_response = double()
         @mock_document = double()
-        @mock_response.stub(:docs => [{ :id => 'my_fake_doc' }, { :id => 'my_other_doc'}])
+        allow(@mock_response).to receive_messages(:docs => [{ :id => 'my_fake_doc' }, { :id => 'my_other_doc'}])
         @mock_document = double()
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
       end
     before(:each) do
@@ -349,24 +349,24 @@ describe CatalogController do
     describe "email" do
       it "should give error if no TO paramater" do
         post :email, :id => doc_id
-        request.flash[:error].should == "You must enter a recipient in order to send this message"
+        expect(request.flash[:error]).to eq("You must enter a recipient in order to send this message")
       end
       it "should give an error if the email address is not valid" do
         post :email, :id => doc_id, :to => 'test_bad_email'
-        request.flash[:error].should == "You must enter a valid email address"
+        expect(request.flash[:error]).to eq("You must enter a valid email address")
       end
       it "should not give error if no Message paramater is set" do
         post :email, :id => doc_id, :to => 'test_email@projectblacklight.org'
-        request.flash[:error].should be_nil
+        expect(request.flash[:error]).to be_nil
       end
       it "should redirect back to the record upon success" do
         mock_mailer = double
-        mock_mailer.should_receive(:deliver)
-        RecordMailer.should_receive(:email_record).with(anything, { :to => 'test_email@projectblacklight.org', :message => 'xyz' }, hash_including(:host => 'test.host')).and_return mock_mailer
+        expect(mock_mailer).to receive(:deliver)
+        expect(RecordMailer).to receive(:email_record).with(anything, { :to => 'test_email@projectblacklight.org', :message => 'xyz' }, hash_including(:host => 'test.host')).and_return mock_mailer
 
         post :email, :id => doc_id, :to => 'test_email@projectblacklight.org', :message => 'xyz'
-        request.flash[:error].should be_nil
-        request.should redirect_to(catalog_path(doc_id))
+        expect(request.flash[:error]).to be_nil
+        expect(request).to redirect_to(catalog_path(doc_id))
       end
 
       it "should render email_sent for XHR requests" do
@@ -378,29 +378,29 @@ describe CatalogController do
     describe "sms" do
       it "should give error if no phone number is given" do
         post :sms, :id => doc_id, :carrier => 'att'
-        request.flash[:error].should == "You must enter a recipient's phone number in order to send this message"
+        expect(request.flash[:error]).to eq("You must enter a recipient's phone number in order to send this message")
       end
       it "should give an error when a carrier is not provided" do
         post :sms, :id => doc_id, :to => '5555555555', :carrier => ''
-        request.flash[:error].should == "You must select a carrier"
+        expect(request.flash[:error]).to eq("You must select a carrier")
       end
       it "should give an error when the phone number is not 10 digits" do
         post :sms, :id => doc_id, :to => '555555555', :carrier => 'txt.att.net'
-        request.flash[:error].should == "You must enter a valid 10 digit phone number"
+        expect(request.flash[:error]).to eq("You must enter a valid 10 digit phone number")
       end
       it "should give an error when the carrier is not in our list of carriers" do
         post :sms, :id => doc_id, :to => '5555555555', :carrier => 'no-such-carrier'
-        request.flash[:error].should == "You must enter a valid carrier"
+        expect(request.flash[:error]).to eq("You must enter a valid carrier")
       end
       it "should allow punctuation in phone number" do
         post :sms, :id => doc_id, :to => '(555) 555-5555', :carrier => 'txt.att.net'
-        request.flash[:error].should be_nil
-        request.should redirect_to(catalog_path(doc_id))
+        expect(request.flash[:error]).to be_nil
+        expect(request).to redirect_to(catalog_path(doc_id))
       end
       it "should redirect back to the record upon success" do
         post :sms, :id => doc_id, :to => '5555555555', :carrier => 'txt.att.net'
-        request.flash[:error].should be_nil
-        request.should redirect_to(catalog_path(doc_id))
+        expect(request.flash[:error]).to be_nil
+        expect(request).to redirect_to(catalog_path(doc_id))
       end
 
       it "should render sms_sent template for XHR requests" do
@@ -414,36 +414,36 @@ describe CatalogController do
   describe "errors" do
     it "should return status 404 for a record that doesn't exist" do
         @mock_response = double()
-        @mock_response.stub(:docs => [])
+        allow(@mock_response).to receive_messages(:docs => [])
         @mock_document = double()
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
       get :show, :id=>"987654321"
-      request.flash[:notice].should == "Sorry, you have requested a record that doesn't exist."
-      response.should render_template('index')
-      response.status.should == 404
+      expect(request.flash[:notice]).to eq("Sorry, you have requested a record that doesn't exist.")
+      expect(response).to render_template('index')
+      expect(response.status).to eq(404)
     end
     it "should redirect the user to the root url for a bad search" do
       req = {}
       res = {}
       fake_error = RSolr::Error::Http.new(req, res) 
-      controller.stub(:get_search_results) { |*args| raise fake_error }
-      controller.logger.should_receive(:error).with(fake_error)
+      allow(controller).to receive(:get_search_results) { |*args| raise fake_error }
+      expect(controller.logger).to receive(:error).with(fake_error)
       get :index, :q=>"+"
 
-      response.redirect_url.should == root_url
-      request.flash[:notice].should == "Sorry, I don't understand your search."
-      response.should_not be_success
-      response.status.should == 302
+      expect(response.redirect_url).to eq(root_url)
+      expect(request.flash[:notice]).to eq("Sorry, I don't understand your search.")
+      expect(response).not_to be_success
+      expect(response.status).to eq(302)
     end
     it "should return status 500 if the catalog path is raising an exception" do
 
       req = {}
       res = {}
       fake_error = RSolr::Error::Http.new(req, res) 
-      controller.stub(:get_search_results) { |*args| raise fake_error }
-      controller.flash.stub(:sweep)
-      controller.stub(:flash).and_return(:notice => I18n.t('blacklight.search.errors.request_error'))
+      allow(controller).to receive(:get_search_results) { |*args| raise fake_error }
+      allow(controller.flash).to receive(:sweep)
+      allow(controller).to receive(:flash).and_return(:notice => I18n.t('blacklight.search.errors.request_error'))
       expect {
       get :index, :q=>"+"
       }.to raise_error 
@@ -455,18 +455,18 @@ describe CatalogController do
     render_views
 
     before do
-      controller.stub(:has_user_authentication_provider?) { false }
+      allow(controller).to receive(:has_user_authentication_provider?) { false }
         @mock_response = double()
         @mock_document = double()
-        @mock_response.stub(:docs => [], :total => 1, :facets => [], :facet_queries => {}, :facet_by_field_name => nil)
+        allow(@mock_response).to receive_messages(:docs => [], :total => 1, :facets => [], :facet_queries => {}, :facet_by_field_name => nil)
         @mock_document = double()
-        controller.stub(:find => @mock_response, 
+        allow(controller).to receive_messages(:find => @mock_response, 
                         :get_single_doc_via_search => @mock_document)
     end
 
     it "should not show user util links" do
       get :index
-      response.body.should_not =~ /Login/
+      expect(response.body).not_to match(/Login/)
     end
   end
 
@@ -474,22 +474,22 @@ describe CatalogController do
     describe "requesting js" do
       it "should be successful" do
         xhr :get, :facet, id: 'format'
-        response.should be_successful
+        expect(response).to be_successful
       end
     end
     describe "requesting html" do
       it "should be successful" do
         get :facet, id: 'format'
-        response.should be_successful
-        assigns[:pagination].should be_kind_of Blacklight::Solr::FacetPaginator
+        expect(response).to be_successful
+        expect(assigns[:pagination]).to be_kind_of Blacklight::Solr::FacetPaginator
       end
     end
     describe "requesting json" do
       it "should be successful" do
         get :facet, id: 'format', format: 'json'
-        response.should be_successful
+        expect(response).to be_successful
         json = JSON.parse(response.body)
-        json["response"]["facets"]["items"].first["value"].should == 'Book'
+        expect(json["response"]["facets"]["items"].first["value"]).to eq('Book')
       end
     end
   end
@@ -497,8 +497,8 @@ describe CatalogController do
   describe 'render_search_results_as_json' do
     before do
       controller.instance_variable_set :@document_list, [{id: '123', title_t: 'Book1'}, {id: '456', title_t: 'Book2'}]
-      controller.stub(:pagination_info).and_return({current_page: 1, next_page: 2, prev_page: nil})
-      controller.stub(:search_facets_as_json).and_return(
+      allow(controller).to receive(:pagination_info).and_return({current_page: 1, next_page: 2, prev_page: nil})
+      allow(controller).to receive(:search_facets_as_json).and_return(
           [{name: "format", label: "Format", items: [{value: 'Book', hits: 30, label: 'Book'}]}])
     end
 
@@ -527,18 +527,18 @@ describe CatalogController do
     it "should prepend the current search to the list" do
       session[:history] = []
       controller.send(:add_to_search_history, double(:id => 1))
-      expect(session[:history]).to have(1).item
+      expect(session[:history].size).to eq(1)
 
       controller.send(:add_to_search_history, double(:id => 2))
-      expect(session[:history]).to have(2).items
+      expect(session[:history].size).to eq(2)
       expect(session[:history].first).to eq 2
     end
 
     it "should remove searches from the list when the list gets too big" do
-      controller.stub(:blacklight_config).and_return(double(:search_history_window => 5))
+      allow(controller).to receive(:blacklight_config).and_return(double(:search_history_window => 5))
       session[:history] = (0..4).to_a.reverse
 
-      expect(session[:history]).to have(5).items
+      expect(session[:history].size).to eq(5)
       controller.send(:add_to_search_history, double(:id => 5))
       controller.send(:add_to_search_history, double(:id => 6))
       controller.send(:add_to_search_history, double(:id => 7))
@@ -549,15 +549,15 @@ describe CatalogController do
 
   describe "current_search_session" do
     it "should create a session if we're on an search action" do
-      controller.stub(:action_name => "index")
-      controller.stub(:params => { :q => "x", :page => 5})
+      allow(controller).to receive_messages(:action_name => "index")
+      allow(controller).to receive_messages(:params => { :q => "x", :page => 5})
       session = controller.send(:current_search_session)
       expect(session.query_params).to include(:q => "x")
       expect(session.query_params).to_not include(:page => 5)
     end
 
     it "should create a session if a search context was provided" do
-      controller.stub(:params => { :search_context => JSON.dump(:q => "x")})
+      allow(controller).to receive_messages(:params => { :search_context => JSON.dump(:q => "x")})
       session = controller.send(:current_search_session)
       expect(session.query_params).to include("q" => "x")
     end
@@ -566,7 +566,7 @@ describe CatalogController do
       s = Search.create(:query_params => { :q => "x" })
       session[:history] ||= []
       session[:history] << s.id
-      controller.stub(:params => { :search_id => s.id})
+      allow(controller).to receive_messages(:params => { :search_id => s.id})
       session = controller.send(:current_search_session)
       expect(session.query_params).to include(:q => "x")
       expect(session).to eq(s)
@@ -575,7 +575,7 @@ describe CatalogController do
     it "should use an existing search session if the search is in the uri" do
       s = Search.create(:query_params => { :q => "x" })
       session[:search] ||= {}
-      session[:search][:id] = s.id
+      session[:search]['id'] = s.id
       session[:history] ||= []
       session[:history] << s.id
       session = controller.send(:current_search_session)
@@ -588,10 +588,10 @@ end
 
 # there must be at least one facet, and each facet must have at least one value
 def assert_facets_have_values(facets)
-  facets.size.should > 1
+  expect(facets.size).to be > 1
   # should have at least one value for each facet
   facets.each do |facet|
-    facet.items.size.should >= 1
+    expect(facet.items.size).to be >= 1
   end
 end