blacklight 4.7.0 → 4.8.0

data/spec/controllers/search_history_controller_spec.rb

@@ -15,26 +15,26 @@ describe SearchHistoryController do
       session[:history] = [@one.id, @three.id]
       get :index
       @searches = assigns(:searches)
-      @searches.length.should == 2
-      @searches.should include(@one)
-      @searches.should include(@three)
-      @searches.should_not include(@two)
+      expect(@searches.length).to eq(2)
+      expect(@searches).to include(@one)
+      expect(@searches).to include(@three)
+      expect(@searches).not_to include(@two)
     end
     
     it "should tolerate bad ids in session" do
       session[:history] = [@one.id, @three.id, "NOT_IN_DB"]
       get :index
       @searches = assigns(:searches)
-      @searches.length.should == 2
-      @searches.should include(@one)
-      @searches.should include(@three)      
+      expect(@searches.length).to eq(2)
+      expect(@searches).to include(@one)
+      expect(@searches).to include(@three)      
     end
     
     it "should not fetch any searches if there is no history" do
       session[:history] = []
       get :index
       @searches = assigns(:searches)
-      @searches.length.should == 0
+      expect(@searches.length).to eq(0)
     end
   end
 

data/spec/features/alternate_controller_spec.rb

@@ -3,17 +3,19 @@ require 'spec_helper'
 describe "Alternate Controller Behaviors" do
   it "should have the correct per-page form" do
     visit alternate_index_path
-    page.should have_selector("form[action='#{alternate_index_path}']")
+    expect(page).to have_selector("form[action='#{alternate_index_path}']")
     fill_in "q", :with=>"history"
     click_button 'search'
     expect(current_path).to match /#{alternate_index_path}/
-    click_on '10 per page'
+    within ("#per_page-dropdown") do
+      click_link '20 per page'
+    end
     expect(current_path).to match /#{alternate_index_path}/
   end
 
   it "should have the correct search field form" do
     visit alternate_index_path
-    page.should have_selector("form[action='#{alternate_index_path}']")
+    expect(page).to have_selector("form[action='#{alternate_index_path}']")
     fill_in "q", :with=>"history"
     click_button 'search'
     expect(current_path).to match /#{alternate_index_path}/
@@ -23,7 +25,7 @@ describe "Alternate Controller Behaviors" do
 
   it "should display document thumbnails" do
     visit alternate_index_path
-    page.should have_selector("form[action='#{alternate_index_path}']")
+    expect(page).to have_selector("form[action='#{alternate_index_path}']")
     fill_in "q", :with=>"history"
     click_button 'search'
     expect(page).to have_selector ".document-thumbnail"
@@ -31,4 +33,4 @@ describe "Alternate Controller Behaviors" do
     expect(page).to have_selector ".document-thumbnail a img"
 
   end
-end
+end

data/spec/features/record_view_spec.rb

@@ -14,7 +14,10 @@ describe "Record View" do
     expect(page).to have_content "Book" 
     expect(page).to have_content "Call number:"
     expect(page).to have_content "E99.D2 H437 2008"
+    tmp_value = Capybara.ignore_hidden_elements
+    Capybara.ignore_hidden_elements = false
     expect(page).to have_selector("link[rel=alternate]")
+    Capybara.ignore_hidden_elements = tmp_value
     
   end
 
@@ -31,7 +34,7 @@ describe "Record View" do
   end
   it "should not display 404" do
     visit catalog_path('this_id_does_not_exist')
-    page.driver.status_code.should == 404
+    expect(page.driver.status_code).to eq(404)
     expect(page).to have_content "Sorry, you have requested a record that doesn't exist." 
   end
 end

data/spec/features/search_filters_spec.rb

@@ -3,11 +3,13 @@ require 'spec_helper'
 describe "Facets" do
   it "should work without a search term" do
     visit root_path
-    click_link "Tibetan"
-    within ("#sortAndPerPage") do
+    within 'div.blacklight-language_facet' do
+      click_link "Tibetan"
+    end
+    within "#sortAndPerPage" do
       expect(page).to have_content "1 - 6 of 6"
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 6")
     end
 
@@ -15,10 +17,10 @@ describe "Facets" do
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 - 2 of 2"
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
-    within(".blacklight-subject_geo_facet") do 
+    within(".blacklight-subject_geo_facet") do
       expect(page).to have_selector("span.selected", :text => "India 2")
     end
   end
@@ -31,11 +33,13 @@ describe "Facets" do
       expect(page).to have_content "1 - 9 of 9"
     end
 
-    click_link "Tibetan"
+    within "div.blacklight-language_facet" do
+      click_link "Tibetan"
+    end
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 - 2 of 2"
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
     within "#appliedParams" do
@@ -48,21 +52,23 @@ describe "Facets" do
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 entry found"
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 1")
     end
-    within(".blacklight-pub_date") do 
+    within(".blacklight-pub_date") do
       expect(page).to have_selector("span.selected", :text => "2004 1")
     end
   end
 
   it "should allow removing filters" do
     visit root_path
-    click_link "Tibetan"
-    within(".blacklight-language_facet") do 
+    within "div.blacklight-language_facet" do
+      click_link "Tibetan"
+    end
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 6")
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       click_link 'remove'
     end
     expect(page).to_not have_link 'remove'
@@ -73,26 +79,28 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-    click_link 'Tibetan'
-    within(".blacklight-language_facet") do 
+    within "div.blacklight-language_facet" do
+      click_link "Tibetan"
+    end
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
 
     click_link '2004'
 
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 1")
     end
-    within(".blacklight-pub_date") do 
+    within(".blacklight-pub_date") do
       expect(page).to have_selector("span.selected", :text => "2004 1")
     end
     fill_in "q", with: 'china'
     click_button 'search'
 
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 1")
     end
-    within(".blacklight-pub_date") do 
+    within(".blacklight-pub_date") do
       expect(page).to have_selector("span.selected", :text => "2004 1")
     end
   end
@@ -101,12 +109,14 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-    click_link 'Tibetan'
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
+      click_link 'Tibetan'
+    end
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
     click_link 'title'
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
     within "#appliedParams" do
@@ -119,14 +129,17 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-    click_link 'Tibetan'
-    within(".blacklight-language_facet") do 
+
+    within("div.blacklight-language_facet") do
+      click_link 'Tibetan'
+    end
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
     within '#per_page-dropdown' do
       click_link '20'
     end
-    within(".blacklight-language_facet") do 
+    within("div.blacklight-language_facet") do
       expect(page).to have_selector("span.selected", :text => "Tibetan 2")
     end
     within "#appliedParams" do

data/spec/features/search_pagination_spec.rb

@@ -16,12 +16,14 @@ describe "Search Pagination" do
       end
 
     end
-    click_link "Next »"
-    within ("#sortAndPerPage") do
+    within '#sortAndPerPage' do
+      click_link "Next »"
+    end
+    within "#sortAndPerPage" do
       expect(page).to have_content "11 - 20 of "
+      click_link "« Previous"
     end
-    click_link "« Previous"
-    within ("#sortAndPerPage") do
+    within "#sortAndPerPage" do
       expect(page).to have_content "1 - 10 of "
     end
   end
@@ -77,14 +79,16 @@ describe "Search Pagination" do
     visit root_path
     fill_in "q", with: ''
     click_button 'search'
-    click_link "Next »"
-    within ("#sortAndPerPage") do
+    within "#sortAndPerPage" do
+      click_link "Next »"
+    end
+    within "#sortAndPerPage" do
       expect(page).to have_content "11 - 20 of "
     end
     within ("#per_page-dropdown") do
       click_link '20'
     end
-    within ("#sortAndPerPage") do
+    within "#sortAndPerPage" do
       expect(page).to have_content "1 - 20 of "
     end
   end

data/spec/features/search_results_spec.rb

@@ -4,40 +4,43 @@ require 'spec_helper'
 describe "Search Results" do
   it "should have for an empty query" do
     search_for ''
-    number_of_results_from_page(page).should == 30
-    page.should have_xpath("//a[contains(@href, #{2007020969})]")
+    expect(number_of_results_from_page(page)).to eq(30)
+    expect(page).to have_xpath("//a[contains(@href, #{2007020969})]")
     search_for 'korea'
-    number_of_results_from_page(page).should == 4
+    expect(number_of_results_from_page(page)).to eq(4)
   end
 
   it "should find same result set with or without diacritcs" do
     search_for 'inmul'
-    number_of_results_from_page(page).should == 1
-    page.should have_xpath("//a[contains(@href, #{77826928})]")
+    expect(number_of_results_from_page(page)).to eq(1)
+    expect(page).to have_xpath("//a[contains(@href, #{77826928})]")
 
     search_for 'inmül'
-    number_of_results_from_page(page).should == 1
+    expect(number_of_results_from_page(page)).to eq(1)
   end
   it "should find same result set for a case-insensitive query " do
     search_for 'inmul'
-    number_of_results_from_page(page).should == 1
-    page.should have_xpath("//a[contains(@href, #{77826928})]")
+    expect(number_of_results_from_page(page)).to eq(1)
+    expect(page).to have_xpath("//a[contains(@href, #{77826928})]")
 
     search_for 'INMUL'
-    number_of_results_from_page(page).should == 1
+    expect(number_of_results_from_page(page)).to eq(1)
   end
 
   it "should order by relevancy" do
     search_for "Korea"
-    position_in_result_page(page, '77826928').should == 1
-    position_in_result_page(page, '94120425').should == 2
-    
+    expect(position_in_result_page(page, '77826928')).to eq(1)
+    expect(position_in_result_page(page, '94120425')).to eq(2)
+
   end
 
   it "should have an opensearch description document" do
     visit root_path
+    tmp_value = Capybara.ignore_hidden_elements
+    Capybara.ignore_hidden_elements = false
     page.should have_xpath("//link[contains(@rel, 'search')]")
     expect(page.find(:xpath, "//link[contains(@rel, 'search')]")[:href]).to eq "http://www.example.com/catalog/opensearch.xml"
+    Capybara.ignore_hidden_elements = tmp_value
   end
 
   it "should provide search hints if there are no results" do
@@ -46,6 +49,7 @@ describe "Search Results" do
   end
 
   it "should pass the current search id through", :js => true do
+    pending
     visit root_path
     fill_in "q", with: ''
     click_button 'search'
@@ -79,7 +83,7 @@ def position_in_result_page(page, id)
   end
   i.to_i
 end
-        
+
 def number_of_results_for_query(query)
   visit root_path
   fill_in "q", :with => query
@@ -88,5 +92,9 @@ def number_of_results_for_query(query)
 end
 
 def number_of_results_from_page(page)
-  page.find("meta[name=totalResults]")['content'].to_i rescue 0
+  tmp_value = Capybara.ignore_hidden_elements
+  Capybara.ignore_hidden_elements = false
+  val = page.find("meta[name=totalResults]")['content'].to_i rescue 0
+  Capybara.ignore_hidden_elements = tmp_value
+  val
 end

data/spec/features/search_sort_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 describe "Search Sort" do
   it "should sort on facet results with no search terms" do
     visit root_path
-    click_link 'English'
+    within("div.blacklight-language_facet") do
+      click_link 'English'
+    end
     expect(page).to have_content 'Sort by relevance'
     click_link 'title'
     expect(page).to have_content 'Sort by title'

data/spec/features/search_spec.rb

@@ -15,7 +15,10 @@ describe "Search Page" do
     expect(page).to_not have_selector("#startOverLink")
    
     expect(page).to have_content "Welcome!"
+    tmp_value = Capybara.ignore_hidden_elements
+    Capybara.ignore_hidden_elements = false
     expect(page).to have_selector("link[rel=stylesheet]")
+    Capybara.ignore_hidden_elements = tmp_value
   end
 
   it "should do searches across all fields" do
@@ -24,6 +27,8 @@ describe "Search Page" do
     select 'All Fields', from: 'search_field'
     click_button 'search'
    
+    tmp_value = Capybara.ignore_hidden_elements
+    Capybara.ignore_hidden_elements = false
     expect(page).to have_selector("link[rel=alternate][type='application/rss+xml']")
     expect(page).to have_selector("link[rel=alternate][type='application/atom+xml']")
 
@@ -31,6 +36,7 @@ describe "Search Page" do
     expect(page).to have_selector("meta[name=totalResults]")
     expect(page).to have_selector("meta[name=startIndex]")
     expect(page).to have_selector("meta[name=itemsPerPage]")
+    Capybara.ignore_hidden_elements = tmp_value
 
     within "#appliedParams" do
       expect(page).to have_content "You searched for:"

data/spec/helpers/blacklight_helper_spec.rb

@@ -1,7 +1,7 @@
 #ste -*- encoding : utf-8 -*-
 # -*- coding: UTF-8 -*-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'marc'
+require 'spec_helper'
+
 def exportable_record
 "<record>
   <leader>01828cjm a2200409 a 4500</leader>
@@ -82,7 +82,7 @@ describe BlacklightHelper do
   end
 
   before(:each) do
-    helper.stub(:search_action_url) do |*args|
+    allow(helper).to receive(:search_action_url) do |*args|
       catalog_index_url *args
     end
   end
@@ -95,21 +95,21 @@ describe BlacklightHelper do
     describe "#index_field_names" do
       it "should warn" do
         expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        helper.stub(:index_fields => {})
+        allow(helper).to receive_messages(:index_fields => {})
         helper.index_field_names
       end
     end
     describe "#index_field_labels" do
       it "should warn" do
         expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        helper.stub(:index_fields => {})
+        allow(helper).to receive_messages(:index_fields => {})
         helper.index_field_labels
       end
     end
     describe "#document_show_field_labels" do
       it "should warn" do
         expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        helper.stub(:document_show_fields => {})
+        allow(helper).to receive_messages(:document_show_fields => {})
         helper.document_show_field_labels
       end
     end
@@ -117,7 +117,7 @@ describe BlacklightHelper do
     describe "#render_document_list_partial" do
       it "should warn" do
         expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        helper.stub(:render)
+        allow(helper).to receive(:render)
         helper.render_document_list_partial
       end
     end
@@ -125,12 +125,12 @@ describe BlacklightHelper do
 
   describe "#application_name", :test => true do
     it "should use the Rails application config application_name if available" do
-      Rails.application.config.stub(:application_name => 'asdf')
-      Rails.application.config.should_receive(:respond_to?).with(:application_name).and_return(true)
-      application_name.should == 'asdf'
+      allow(Rails.application.config).to receive_messages(:application_name => 'asdf')
+      expect(Rails.application.config).to receive(:respond_to?).with(:application_name).and_return(true)
+      expect(application_name).to eq('asdf')
     end
     it "should default to 'Blacklight'" do
-      application_name.should == "Blacklight"
+      expect(application_name).to eq("Blacklight")
     end
   end
 
@@ -141,50 +141,50 @@ describe BlacklightHelper do
     end
 
     it "should build a link tag to catalog using session[:search] for query params" do
-      helper.stub(:current_search_session).and_return double(:query_params => @query_params)
+      allow(helper).to receive(:current_search_session).and_return double(:query_params => @query_params)
       tag = helper.link_back_to_catalog
-      tag.should =~ /q=query/
-      tag.should =~ /f=facets/
-      tag.should =~ /per_page=10/
-      tag.should =~ /page=2/
+      expect(tag).to match(/q=query/)
+      expect(tag).to match(/f=facets/)
+      expect(tag).to match(/per_page=10/)
+      expect(tag).to match(/page=2/)
     end
 
     it "should build a link tag to bookmarks using session[:search] for query params" do
-      helper.stub(:current_search_session).and_return double(:query_params => @bookmarks_query_params)
+      allow(helper).to receive(:current_search_session).and_return double(:query_params => @bookmarks_query_params)
       tag = helper.link_back_to_catalog
-      tag.should =~ /Back to Bookmarks/
-      tag.should =~ /\/bookmarks/
-      tag.should =~ /page=2/
+      expect(tag).to match(/Back to Bookmarks/)
+      expect(tag).to match(/\/bookmarks/)
+      expect(tag).to match(/page=2/)
     end
   end
 
   describe "link_to_query" do
     it "should build a link tag to catalog using query string (no other params)" do
       query = "brilliant"
-      self.should_receive(:params).and_return({})
+      expect(self).to receive(:params).and_return({})
       tag = link_to_query(query)
-      tag.should =~ /q=#{query}/
-      tag.should =~ />#{query}<\/a>/
+      expect(tag).to match(/q=#{query}/)
+      expect(tag).to match(/>#{query}<\/a>/)
     end
     it "should build a link tag to catalog using query string and other existing params" do
       query = "wonderful"
-      self.should_receive(:params).and_return({:qt => "title_search", :per_page => "50"})
+      expect(self).to receive(:params).and_return({:qt => "title_search", :per_page => "50"})
       tag = link_to_query(query)
-      tag.should =~ /qt=title_search/
-      tag.should =~ /per_page=50/
+      expect(tag).to match(/qt=title_search/)
+      expect(tag).to match(/per_page=50/)
     end
     it "should ignore existing :page param" do
       query = "yes"
-      self.should_receive(:params).and_return({:page => "2", :qt => "author_search"})
+      expect(self).to receive(:params).and_return({:page => "2", :qt => "author_search"})
       tag = link_to_query(query)
-      tag.should =~ /qt=author_search/
-      tag.should_not =~ /page/
+      expect(tag).to match(/qt=author_search/)
+      expect(tag).not_to match(/page/)
     end
     it "should be html_safe" do
       query = "brilliant"
-      self.should_receive(:params).and_return({:page => "2", :qt => "author_search"})
+      expect(self).to receive(:params).and_return({:page => "2", :qt => "author_search"})
       tag = link_to_query(query)
-      tag.html_safe?.should == true
+      expect(tag.html_safe?).to eq(true)
     end
   end
 
@@ -212,24 +212,24 @@ describe BlacklightHelper do
 
     it "should default to using the controller's params" do
       result = params_for_search
-      result.should == params
-      params.object_id.should_not == result.object_id
+      expect(result).to eq(params)
+      expect(params.object_id).not_to eq(result.object_id)
     end
 
     it "should let you pass in params to use" do
       source_params = { :q => 'query'}
       result = params_for_search(source_params, {})
-      source_params.should == result
-      source_params.object_id.should_not == result.object_id
+      expect(source_params).to eq(result)
+      expect(source_params.object_id).not_to eq(result.object_id)
     end
 
     it "should let you pass in params to use (the deprecated way)" do
       source_params = { :q => 'query'}
       result = params_for_search(:params => source_params )
-      source_params.should == result
-      source_params.object_id.should_not == result.object_id
+      expect(source_params).to eq(result)
+      expect(source_params.object_id).not_to eq(result.object_id)
     end
-    
+
 
     it "should let you pass in params to merge into the controller's params" do
       source_params = { :q => 'query'}
@@ -240,32 +240,32 @@ describe BlacklightHelper do
     it "should not return blacklisted elements" do
       source_params = { :action => 'action', :controller => 'controller', :id => "id", :commit => 'commit'}
       result = params_for_search(source_params, {} )
-      result.keys.should_not include(:action, :controller, :commit, :id)
+      expect(result.keys).not_to include(:action, :controller, :commit, :id)
 
     end
 
     it "should adjust the current page if the per_page changes" do
       source_params = { :per_page => 20, :page => 5}
       result = params_for_search(source_params, :per_page => 100)
-      result[:page].should == 1
+      expect(result[:page]).to eq(1)
     end
 
     it "should not adjust the current page if the per_page is the same as it always was" do
       source_params = { :per_page => 20, :page => 5}
       result = params_for_search(source_params, :per_page => 20)
-      result[:page].should == 5
+      expect(result[:page]).to eq(5)
     end
 
     it "should adjust the current page if the sort changes" do
       source_params = { :sort => 'field_a', :page => 5}
       result = params_for_search(source_params, :sort => 'field_b')
-      result[:page].should == 1
+      expect(result[:page]).to eq(1)
     end
 
     it "should not adjust the current page if the sort is the same as it always was" do
       source_params = { :sort => 'field_a', :page => 5}
       result = params_for_search(source_params, :sort => 'field_a')
-      result[:page].should == 5
+      expect(result[:page]).to eq(5)
     end
 
     describe "omit keys parameter" do
@@ -273,33 +273,33 @@ describe BlacklightHelper do
         source_params = { :a => 1, :b => 2, :c => 3}
         result = params_for_search(source_params, :omit_keys => [:a, :b] )
 
-        result.keys.should_not include(:a, :b)
-        result[:c].should == 3
+        expect(result.keys).not_to include(:a, :b)
+        expect(result[:c]).to eq(3)
       end
 
       it "should remove keys if a key/value pair was passed and no values are left for that key" do
         source_params = { :f => ['a']}
         result = params_for_search(source_params, :omit_keys => [{:f => 'a' }])
-        result.keys.should_not include(:f)
+        expect(result.keys).not_to include(:f)
       end
 
       it "should only remove keys when a key/value pair is based that are in that pair" do
 
         source_params = { :f => ['a', 'b']}
         result = params_for_search(source_params, :omit_keys => [{:f => 'a' }])
-        result[:f].should_not include('a')
-        result[:f].should include('b')
+        expect(result[:f]).not_to include('a')
+        expect(result[:f]).to include('b')
       end
     end
 
      describe "params_for_search with a block" do
       it "should evalute the block and allow it to add or remove keys" do
         result = params_for_search({:a => 1, :b => 2}, :c => 3) do |params|
-          params.except! :a, :b 
+          params.except! :a, :b
           params[:d] = 'd'
         end
 
-        result.keys.should_not include(:a, :b)
+        expect(result.keys).not_to include(:a, :b)
         expect(result[:c]).to eq 3
         expect(result[:d]).to eq 'd'
       end
@@ -315,7 +315,7 @@ describe BlacklightHelper do
     describe "for default arguments" do
       it "should default to omitting :page" do
         Deprecation.silence(Blacklight::BlacklightHelperBehavior) do
-          search_as_hidden_fields.should_not have_selector("input[name='page']")
+          expect(search_as_hidden_fields).not_to have_selector("input[name='page']")
         end
       end
     end
@@ -325,18 +325,18 @@ describe BlacklightHelper do
    describe "render body class" do
       it "should include a serialization of the current controller name" do
         @controller = double("controller")
-        @controller.stub(:controller_name).and_return("123456")
-        @controller.stub(:action_name).and_return("abcdef")
+        allow(@controller).to receive(:controller_name).and_return("123456")
+        allow(@controller).to receive(:action_name).and_return("abcdef")
 
-	render_body_class.split(' ').should include('blacklight-123456')
+	expect(render_body_class.split(' ')).to include('blacklight-123456')
       end
 
       it "should include a serialization of the current action name" do
         @controller = double("controller")
-        @controller.stub(:controller_name).and_return("123456")
-        @controller.stub(:action_name).and_return("abcdef")
+        allow(@controller).to receive(:controller_name).and_return("123456")
+        allow(@controller).to receive(:action_name).and_return("abcdef")
 
-	render_body_class.split(' ').should include('blacklight-123456-abcdef')
+	expect(render_body_class.split(' ')).to include('blacklight-123456-abcdef')
       end
    end
 
@@ -345,12 +345,12 @@ describe BlacklightHelper do
      it "should consist of the show heading field when available" do
       @document = SolrDocument.new('title_display' => "A Fake Document")
 
-      document_heading.should == "A Fake Document"
+      expect(document_heading).to eq("A Fake Document")
      end
 
      it "should fallback on the document id if no title is available" do
        @document = SolrDocument.new(:id => '123456')
-       document_heading.should == '123456'
+       expect(document_heading).to eq('123456')
      end
    end
 
@@ -358,40 +358,40 @@ describe BlacklightHelper do
      it "should consist of #document_heading wrapped in a <h1>" do
       @document = SolrDocument.new('title_display' => "A Fake Document")
 
-      render_document_heading.should have_selector("h4", :text => "A Fake Document", :count => 1)
-      render_document_heading.html_safe?.should == true
+      expect(render_document_heading).to have_selector("h4", :text => "A Fake Document", :count => 1)
+      expect(render_document_heading.html_safe?).to eq(true)
      end
      it "should join the values if it is an array" do
       @document = SolrDocument.new('title_display' => ["A Fake Document", 'Something Else'])
 
-      render_document_heading.should have_selector("h4", :text => "A Fake Document, Something Else", :count => 1)
-      render_document_heading.html_safe?.should == true
+      expect(render_document_heading).to have_selector("h4", :text => "A Fake Document, Something Else", :count => 1)
+      expect(render_document_heading.html_safe?).to eq(true)
      end
    end
 
    describe "document_show_html_title" do
      it "should join the values if it is an array" do
       @document = SolrDocument.new('title_display' => ["A Fake Document", 'Something Else'])
-      document_show_html_title.should == "A Fake Document, Something Else"
+      expect(document_show_html_title).to eq("A Fake Document, Something Else")
      end
    end
 
    describe "document_index_view_type" do
      it "should default to 'list'" do
-       document_index_view_type.should == 'list'
+       expect(document_index_view_type).to eq('list')
      end
 
      it "should pluck values out of params" do
-       blacklight_config.stub(:document_index_view_types) { ['list', 'asdf'] }
+       allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'asdf'] }
        params[:view] = 'asdf'
-       document_index_view_type.should == 'asdf'
+       expect(document_index_view_type).to eq('asdf')
 
        params[:view] = 'not_in_list'
-       document_index_view_type.should == 'list'
+       expect(document_index_view_type).to eq('list')
      end
 
      it "should pluck values from supplied params" do
-       blacklight_config.stub(:document_index_view_types) { ['list', 'asdf'] }
+       allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'asdf'] }
        params[:view] = 'asdf'
        expect(document_index_view_type(:view => 'list')).to eq 'list'
      end
@@ -399,14 +399,14 @@ describe BlacklightHelper do
 
    describe "start_over_path" do
     it 'should be the catalog path with the current view type' do
-      blacklight_config.stub(:document_index_view_types) { ['list', 'abc'] }
-      helper.stub(:blacklight_config => blacklight_config)
+      allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'abc'] }
+      allow(helper).to receive_messages(:blacklight_config => blacklight_config)
       expect(helper.start_over_path(:view => 'abc')).to eq catalog_index_url(:view => 'abc')
     end
 
     it 'should not include the current view type if it is the default' do
-      blacklight_config.stub(:document_index_view_types) { ['list', 'abc'] }
-      helper.stub(:blacklight_config => blacklight_config)
+      allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'abc'] }
+      allow(helper).to receive_messages(:blacklight_config => blacklight_config)
       expect(helper.start_over_path(:view => 'list')).to eq catalog_index_url
     end
    end
@@ -414,41 +414,41 @@ describe BlacklightHelper do
    describe "render_document_index" do
      it "should render the document_list" do
        @document_list = ['a', 'b']
-       self.should_receive(:render).with(hash_including(:partial => 'document_gallery'))
+       expect(self).to receive(:render).with(hash_including(:partial => 'document_gallery'))
        render_document_index_with_view 'gallery', @document_list
      end
 
      it "should fall back on more specific templates" do
        ex = ActionView::MissingTemplate.new [], '', '', '',''
-       self.should_receive(:render).with(hash_including(:partial => 'document_gallery')).and_raise(ex)
-       self.should_receive(:render).with(hash_including(:partial => 'catalog/document_gallery')).and_raise(ex)
-       self.should_receive(:render).with(hash_including(:partial => 'catalog/document_list'))
+       expect(self).to receive(:render).with(hash_including(:partial => 'document_gallery')).and_raise(ex)
+       expect(self).to receive(:render).with(hash_including(:partial => 'catalog/document_gallery')).and_raise(ex)
+       expect(self).to receive(:render).with(hash_including(:partial => 'catalog/document_list'))
        render_document_index_with_view 'gallery', @document_list
      end
    end
 
    describe "document_partial_name" do
      it "should default to 'default' when a format blank" do
-       document_partial_name({}).should == "default"
+       expect(document_partial_name({})).to eq("default")
      end
      it "should handle normal formats correctly" do
-       document_partial_name({"format" => "myformat"}).should == "myformat"
+       expect(document_partial_name({"format" => "myformat"})).to eq("myformat")
      end
      it "should handle spaces correctly" do
-       document_partial_name({"format" => "my format"}).should == "my_format"
+       expect(document_partial_name({"format" => "my format"})).to eq("my_format")
      end
      it "should handle capitalization correctly" do
-       document_partial_name({"format" => "MyFormat"}).should == "myformat"
+       expect(document_partial_name({"format" => "MyFormat"})).to eq("myformat")
      end
      it "should handle puncuation correctly" do
-       document_partial_name({"format" => "My.Format"}).should == "my_format"
+       expect(document_partial_name({"format" => "My.Format"})).to eq("my_format")
      end
      it "should handle multi-valued fields correctly" do
-       document_partial_name({"format" => ["My Format", "My OtherFormat"]}).should == "my_format_my_otherformat"
+       expect(document_partial_name({"format" => ["My Format", "My OtherFormat"]})).to eq("my_format_my_otherformat")
      end
      it "should remove - characters because they will throw errors" do
-       document_partial_name({"format" => "My-Format"}).should == "my_format"
-       document_partial_name({"format" => ["My-Format",["My Other-Format"]]}).should == "my_format_my_other_format"
+       expect(document_partial_name({"format" => "My-Format"})).to eq("my_format")
+       expect(document_partial_name({"format" => ["My-Format",["My Other-Format"]]})).to eq("my_format_my_other_format")
      end
    end
 
@@ -456,45 +456,45 @@ describe BlacklightHelper do
      it "should consist of the document title wrapped in a <a>" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => :title_display }).should have_selector("a", :text => '654321', :count => 1)
+      expect(link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '654321', :count => 1)
      end
      it "should accept and return a string label" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => "title_display" }).should have_selector("a", :text => 'title_display', :count => 1)
+      expect(link_to_document(@document, { :label => "title_display" })).to have_selector("a", :text => 'title_display', :count => 1)
      end
 
      it "should accept and return a Proc" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => Proc.new { |doc, opts| doc.get(:id) + ": " + doc.get(:title_display) } }).should have_selector("a", :text => '123456: 654321', :count => 1)
+      expect(link_to_document(@document, { :label => Proc.new { |doc, opts| doc.get(:id) + ": " + doc.get(:title_display) } })).to have_selector("a", :text => '123456: 654321', :count => 1)
      end
      it "should return id when label is missing" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => :title_display }).should have_selector("a", :text => '123456', :count => 1)
+      expect(link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '123456', :count => 1)
      end
 
      it "should be html safe" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => :title_display }).html_safe?.should == true
+      expect(link_to_document(@document, { :label => :title_display }).html_safe?).to eq(true)
      end
 
      it "should convert the counter parameter into a data- attribute" do
       data = {'id'=>'123456','title_display'=>['654321']}
       @document = SolrDocument.new(data)
-      link_to_document(@document, { :label => :title_display, :counter => 5  }).should =~ /data-counter="5"/
+      expect(link_to_document(@document, { :label => :title_display, :counter => 5  })).to match(/data-counter="5"/)
      end
 
      it "passes on the title attribute to the link_to_with_data method" do
        @document = SolrDocument.new('id'=>'123456')
-       link_to_document(@document,:label=>"Some crazy long label...",:title=>"Some crazy longer label").should match(/title=\"Some crazy longer label\"/)
+       expect(link_to_document(@document,:label=>"Some crazy long label...",:title=>"Some crazy longer label")).to match(/title=\"Some crazy longer label\"/)
      end
 
      it "doesn't add an erroneous title attribute if one isn't provided" do
        @document = SolrDocument.new('id'=>'123456')
-       link_to_document(@document,:label=>"Some crazy long label...").should_not match(/title=/)
+       expect(link_to_document(@document,:label=>"Some crazy long label...")).not_to match(/title=/)
      end
    end
 
@@ -521,35 +521,44 @@ describe BlacklightHelper do
       @doc_id = "MOCK_ID1"
       @document = MockDocumentAppHelper.new(:id => @doc_id)
       render_params = {:controller => "controller", :action => "action"}
-      helper.stub(:params).and_return(render_params)
+      allow(helper).to receive(:params).and_return(render_params)
     end
     it "generates <link rel=alternate> tags" do
 
       response = render_link_rel_alternates(@document)
 
+      tmp_value = Capybara.ignore_hidden_elements
+      Capybara.ignore_hidden_elements = false
       @document.export_formats.each_pair do |format, spec|
-        response.should have_selector("link[href$='.#{ format  }']") do |matches|
-          matches.length.should == 1
+        expect(response).to have_selector("link[href$='.#{ format  }']") do |matches|
+          expect(matches.length).to eq(1)
           tag = matches[0]
-          tag.attributes["rel"].value.should == "alternate"
-          tag.attributes["title"].value.should == format.to_s
-          tag.attributes["href"].value.should === mock_document_app_helper_url(@document, :format =>format)
+          expect(tag.attributes["rel"].value).to eq("alternate")
+          expect(tag.attributes["title"].value).to eq(format.to_s)
+          expect(tag.attributes["href"].value).to be === mock_document_app_helper_url(@document, :format =>format)
         end
       end
+      Capybara.ignore_hidden_elements = tmp_value
     end
     it "respects :unique=>true" do
       response = render_link_rel_alternates(@document, :unique => true)
+      tmp_value = Capybara.ignore_hidden_elements
+      Capybara.ignore_hidden_elements = false
       response.should have_selector("link[type='application/weird']", :count => 1)
+      Capybara.ignore_hidden_elements = tmp_value
     end
     it "excludes formats from :exclude" do
       response = render_link_rel_alternates(@document, :exclude => [:weird_dup])
 
+      tmp_value = Capybara.ignore_hidden_elements
+      Capybara.ignore_hidden_elements = false
       response.should_not have_selector("link[href$='.weird_dup']")
+      Capybara.ignore_hidden_elements = tmp_value
     end
 
     it "should be html safe" do
       response = render_link_rel_alternates(@document)
-      response.html_safe?.should == true
+      expect(response.html_safe?).to eq(true)
     end
   end
 
@@ -565,20 +574,20 @@ describe BlacklightHelper do
       end
 
       @document = SolrDocument.new('title_display' => "A Fake Document", 'id'=>'8')
-      helper.stub(:blacklight_config).and_return(@config)
-      helper.stub(:has_user_authentication_provider?).and_return(true)
-      helper.stub(:current_or_guest_user).and_return(User.new)
+      allow(helper).to receive(:blacklight_config).and_return(@config)
+      allow(helper).to receive(:has_user_authentication_provider?).and_return(true)
+      allow(helper).to receive(:current_or_guest_user).and_return(User.new)
     end
     describe "render_index_doc_actions" do
       it "should render partials" do
         response = helper.render_index_doc_actions(@document)
-        response.should have_selector(".bookmark_toggle")
+        expect(response).to have_selector(".bookmark_toggle")
       end
     end
     describe "render_show_doc_actions" do
       it "should render partials" do
         response = helper.render_show_doc_actions(@document)
-        response.should have_selector(".bookmark_toggle")
+        expect(response).to have_selector(".bookmark_toggle")
       end
     end
   end
@@ -592,67 +601,67 @@ describe BlacklightHelper do
         config.add_index_field 'link_to_search_named', :link_to_search => :some_field
         config.add_index_field 'highlight', :highlight => true
       end
-      helper.stub(:blacklight_config).and_return(@config)
+      allow(helper).to receive(:blacklight_config).and_return(@config)
     end
 
     it "should check for an explicit value" do
       doc = double()
-      doc.should_not_receive(:get).with('asdf', :sep => nil)
+      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
       value = helper.render_index_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      value.should == 'asdf'
+      expect(value).to eq('asdf')
     end
 
     it "should check for a helper method to call" do
       doc = double()
-      doc.should_not_receive(:get).with('asdf', :sep => nil)
-      helper.stub(:render_asdf_index_field).and_return('custom asdf value')
+      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
+      allow(helper).to receive(:render_asdf_index_field).and_return('custom asdf value')
       value = helper.render_index_field_value :document => doc, :field => 'asdf'
-      value.should == 'custom asdf value'
+      expect(value).to eq('custom asdf value')
     end
 
     it "should check for a link_to_search" do
       doc = double()
-      doc.should_receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
+      expect(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
       value = helper.render_index_field_value :document => doc, :field => 'link_to_search_true'
-      value.should == helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] }))
+      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] })))
     end
 
     it "should check for a link_to_search with a field name" do
       doc = double()
-      doc.should_receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
+      expect(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
       value = helper.render_index_field_value :document => doc, :field => 'link_to_search_named'
-      value.should == helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] }))
+      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] })))
     end
 
     it "should gracefully handle when no highlight field is available" do
       doc = double()
-      doc.should_not_receive(:get)
-      doc.should_receive(:has_highlight_field?).and_return(false)
+      expect(doc).not_to receive(:get)
+      expect(doc).to receive(:has_highlight_field?).and_return(false)
       value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      value.should be_blank
+      expect(value).to be_blank
     end
 
     it "should check for a highlighted field" do
       doc = double()
-      doc.should_not_receive(:get)
-      doc.should_receive(:has_highlight_field?).and_return(true)
-      doc.should_receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
+      expect(doc).not_to receive(:get)
+      expect(doc).to receive(:has_highlight_field?).and_return(true)
+      expect(doc).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
       value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      value.should == '<em>highlight</em>'
+      expect(value).to eq('<em>highlight</em>')
     end
 
     it "should check the document field value" do
       doc = double()
-      doc.should_receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
+      expect(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
       value = helper.render_index_field_value :document => doc, :field => 'qwer'
-      value.should == 'document qwer value'
+      expect(value).to eq('document qwer value')
     end
 
     it "should work with index fields that aren't explicitly defined" do
       doc = double()
-      doc.should_receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
+      expect(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
       value = helper.render_index_field_value :document => doc, :field => 'mnbv'
-      value.should == 'document mnbv value'
+      expect(value).to eq('document mnbv value')
     end
   end
 
@@ -666,86 +675,86 @@ describe BlacklightHelper do
         config.add_show_field 'link_to_search_named', :link_to_search => :some_field
         config.add_show_field 'highlight', :highlight => true
       end
-      helper.stub(:blacklight_config).and_return(@config)
+      allow(helper).to receive(:blacklight_config).and_return(@config)
     end
 
     it "should check for an explicit value" do
       doc = double()
-      doc.should_not_receive(:get).with('asdf', :sep => nil)
-      helper.should_not_receive(:render_asdf_document_show_field)
+      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
+      expect(helper).not_to receive(:render_asdf_document_show_field)
       value = helper.render_document_show_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      value.should == 'asdf'
+      expect(value).to eq('asdf')
     end
 
     it "should check for a helper method to call" do
       doc = double()
-      doc.should_not_receive(:get).with('asdf', :sep => nil)
-      helper.stub(:render_asdf_document_show_field).and_return('custom asdf value')
+      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
+      allow(helper).to receive(:render_asdf_document_show_field).and_return('custom asdf value')
       value = helper.render_document_show_field_value :document => doc, :field => 'asdf'
-      value.should == 'custom asdf value'
+      expect(value).to eq('custom asdf value')
     end
 
     it "should check for a link_to_search" do
       doc = double()
-      doc.should_receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
+      expect(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
       value = helper.render_document_show_field_value :document => doc, :field => 'link_to_search_true'
-      value.should == helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] }))
+      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] })))
     end
 
     it "should check for a link_to_search with a field name" do
       doc = double()
-      doc.should_receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
+      expect(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
       value = helper.render_document_show_field_value :document => doc, :field => 'link_to_search_named'
-      value.should == helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] }))
+      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] })))
     end
 
     it "should gracefully handle when no highlight field is available" do
       doc = double()
-      doc.should_not_receive(:get)
-      doc.should_receive(:has_highlight_field?).and_return(false)
+      expect(doc).not_to receive(:get)
+      expect(doc).to receive(:has_highlight_field?).and_return(false)
       value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      value.should be_blank
+      expect(value).to be_blank
     end
 
     it "should check for a highlighted field" do
       doc = double()
-      doc.should_not_receive(:get)
-      doc.should_receive(:has_highlight_field?).and_return(true)
-      doc.should_receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
+      expect(doc).not_to receive(:get)
+      expect(doc).to receive(:has_highlight_field?).and_return(true)
+      expect(doc).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
       value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      value.should == '<em>highlight</em>'
+      expect(value).to eq('<em>highlight</em>')
     end
 
 
     it "should check the document field value" do
       doc = double()
-      doc.should_receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
+      expect(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
       value = helper.render_document_show_field_value :document => doc, :field => 'qwer'
-      value.should == 'document qwer value'
+      expect(value).to eq('document qwer value')
     end
 
     it "should work with show fields that aren't explicitly defined" do
       doc = double()
-      doc.should_receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
+      expect(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
       value = helper.render_document_show_field_value :document => doc, :field => 'mnbv'
-      value.should == 'document mnbv value'
+      expect(value).to eq('document mnbv value')
     end
   end
 
   describe "#should_render_index_field?" do
     it "should if the document has the field value" do
       doc = double()
-      doc.stub(:has?).with('asdf').and_return(true)
+      allow(doc).to receive(:has?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf')
-      helper.should_render_index_field?(doc, field_config).should == true
+      expect(helper.should_render_index_field?(doc, field_config)).to eq(true)
     end
 
     it "should if the document has a highlight field value" do
       doc = double()
-      doc.stub(:has?).with('asdf').and_return(false)
-      doc.stub(:has_highlight_field?).with('asdf').and_return(true)
+      allow(doc).to receive(:has?).with('asdf').and_return(false)
+      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf', :highlight => true)
-      helper.should_render_index_field?(doc, field_config).should == true
+      expect(helper.should_render_index_field?(doc, field_config)).to eq(true)
     end
   end
 
@@ -753,17 +762,17 @@ describe BlacklightHelper do
   describe "#should_render_show_field?" do
     it "should if the document has the field value" do
       doc = double()
-      doc.stub(:has?).with('asdf').and_return(true)
+      allow(doc).to receive(:has?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf')
-      helper.should_render_show_field?(doc, field_config).should == true
+      expect(helper.should_render_show_field?(doc, field_config)).to eq(true)
     end
 
     it "should if the document has a highlight field value" do
       doc = double()
-      doc.stub(:has?).with('asdf').and_return(false)
-      doc.stub(:has_highlight_field?).with('asdf').and_return(true)
+      allow(doc).to receive(:has?).with('asdf').and_return(false)
+      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf', :highlight => true)
-      helper.should_render_show_field?(doc, field_config).should == true
+      expect(helper.should_render_show_field?(doc, field_config)).to eq(true)
     end
   end
 
@@ -771,13 +780,13 @@ describe BlacklightHelper do
   describe "render_grouped_response?" do
     it "should check if the response ivar contains grouped data" do
       assign(:response, double("SolrResponse", :grouped? => true))
-      expect(helper.render_grouped_response?).to be_true
+      expect(helper.render_grouped_response?).to eq true
     end
 
 
     it "should check if the response param contains grouped data" do
       response = double("SolrResponse", :grouped? => true)
-      expect(helper.render_grouped_response?(response)).to be_true
+      expect(helper.render_grouped_response?(response)).to eq true
     end
   end
 
@@ -791,7 +800,7 @@ describe BlacklightHelper do
     end
 
     it "should join values using the field_value_separator" do
-      helper.stub(:field_value_separator).and_return(" -- ")
+      allow(helper).to receive(:field_value_separator).and_return(" -- ")
       expect(helper.render_field_value(['a', 'b'])).to eq "a -- b"
     end
 
@@ -803,28 +812,28 @@ describe BlacklightHelper do
   describe "link_to_previous_search" do
     it "should link to the given search parameters" do
       params = {}
-      helper.should_receive(:render_search_to_s).with(params).and_return "link text"
+      expect(helper).to receive(:render_search_to_s).with(params).and_return "link text"
       expect(helper.link_to_previous_search({})).to eq helper.link_to("link text", catalog_index_path)
     end
   end
 
   describe "should_show_spellcheck_suggestions?" do
     before :each do
-      helper.stub spell_check_max: 5
+      allow(helper).to receive_messages spell_check_max: 5
     end
     it "should not show suggestions if there are enough results" do
       response = double(total: 10)
-      expect(helper.should_show_spellcheck_suggestions? response).to be_false
+      expect(helper.should_show_spellcheck_suggestions? response).to eq false
     end
 
     it "should only show suggestions if there are very few results" do
       response = double(total: 4, spelling: double(words: [1]))
-      expect(helper.should_show_spellcheck_suggestions? response).to be_true
+      expect(helper.should_show_spellcheck_suggestions? response).to eq true
     end
 
     it "should show suggestions only if there are spelling suggestions available" do
       response = double(total: 4, spelling: double(words: []))
-      expect(helper.should_show_spellcheck_suggestions? response).to be_false
+      expect(helper.should_show_spellcheck_suggestions? response).to eq false
     end
   end
 end