blacklight 4.9.0 → 5.0.0.pre1

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)
-      expect(@searches.length).to eq(2)
-      expect(@searches).to include(@one)
-      expect(@searches).to include(@three)
-      expect(@searches).not_to include(@two)
+      @searches.length.should == 2
+      @searches.should include(@one)
+      @searches.should include(@three)
+      @searches.should_not 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)
-      expect(@searches.length).to eq(2)
-      expect(@searches).to include(@one)
-      expect(@searches).to include(@three)      
+      @searches.length.should == 2
+      @searches.should include(@one)
+      @searches.should include(@three)      
     end
     
     it "should not fetch any searches if there is no history" do
       session[:history] = []
       get :index
       @searches = assigns(:searches)
-      expect(@searches.length).to eq(0)
+      @searches.length.should == 0
     end
   end
 

data/spec/features/alternate_controller_spec.rb

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

data/spec/features/facets_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Facets" do
+  it "should show a single facet's values" do
+    visit catalog_facet_path("language_facet")
+    expect(page).to have_selector(".modal-title", :text => "Language")
+    expect(page).to have_selector(".facet_select", :text => "Tibetan")
+  end
+end

data/spec/features/record_view_spec.rb

@@ -34,7 +34,7 @@ describe "Record View" do
   end
   it "should not display 404" do
     visit catalog_path('this_id_does_not_exist')
-    expect(page.driver.status_code).to eq(404)
+    page.driver.status_code.should == 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,25 +3,32 @@ require 'spec_helper'
 describe "Facets" do
   it "should work without a search term" do
     visit root_path
-    within 'div.blacklight-language_facet' do
+    within '#facet-language' do
       click_link "Tibetan"
     end
     within "#sortAndPerPage" do
       expect(page).to have_content "1 - 6 of 6"
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 6")
+
+    expect(page).to have_selector(".blacklight-language_facet")
+    expect(page).to have_selector(".blacklight-language_facet.facet_limit-active")
+    
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "6")
     end
 
     click_link "India"
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 - 2 of 2"
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
-    within(".blacklight-subject_geo_facet") do
-      expect(page).to have_selector("span.selected", :text => "India 2")
+    within "#facet-region" do
+      expect(page).to have_selector("span.selected", :text => "India")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
   end
 
@@ -33,14 +40,15 @@ describe "Facets" do
       expect(page).to have_content "1 - 9 of 9"
     end
 
-    within "div.blacklight-language_facet" do
+    within "#facet-language" do
       click_link "Tibetan"
     end
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 - 2 of 2"
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
     within "#appliedParams" do
       expect(page).to have_content "You searched for:"
@@ -52,23 +60,26 @@ describe "Facets" do
     within ("#sortAndPerPage") do
       expect(page).to have_content "1 entry found"
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 1")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
-    within(".blacklight-pub_date") do
-      expect(page).to have_selector("span.selected", :text => "2004 1")
+    within(".blacklight-pub_date") do 
+      expect(page).to have_selector("span.selected", :text => "2004")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
   end
 
   it "should allow removing filters" do
     visit root_path
-    within "div.blacklight-language_facet" do
+    within "#facet-language" do
       click_link "Tibetan"
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 6")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "6")
     end
-    within("div.blacklight-language_facet") do
+    within "#facet-language" do
       click_link 'remove'
     end
     expect(page).to_not have_link 'remove'
@@ -79,29 +90,34 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-    within "div.blacklight-language_facet" do
-      click_link "Tibetan"
+    within "#facet-language" do
+      click_link 'Tibetan'
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
 
     click_link '2004'
 
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 1")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
-    within(".blacklight-pub_date") do
-      expect(page).to have_selector("span.selected", :text => "2004 1")
+    within(".blacklight-pub_date") do 
+      expect(page).to have_selector("span.selected", :text => "2004")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
     fill_in "q", with: 'china'
     click_button 'search'
 
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 1")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
-    within(".blacklight-pub_date") do
-      expect(page).to have_selector("span.selected", :text => "2004 1")
+    within(".blacklight-pub_date") do 
+      expect(page).to have_selector("span.selected", :text => "2004")
+      expect(page).to have_selector("span.facet-count.selected", :text => "1")
     end
   end
 
@@ -109,15 +125,17 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-    within("div.blacklight-language_facet") do
+    within "#facet-language" do
       click_link 'Tibetan'
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
     click_link 'title'
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
     within "#appliedParams" do
       expect(page).to have_content "You searched for:"
@@ -129,22 +147,60 @@ describe "Facets" do
     visit root_path
     fill_in "q", with: 'history'
     click_button 'search'
-
-    within("div.blacklight-language_facet") do
+    within "#facet-language" do
       click_link 'Tibetan'
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
     within '#per_page-dropdown' do
       click_link '20'
     end
-    within("div.blacklight-language_facet") do
-      expect(page).to have_selector("span.selected", :text => "Tibetan 2")
+    within "#facet-language" do
+      expect(page).to have_selector("span.selected", :text => "Tibetan")
+      expect(page).to have_selector("span.facet-count.selected", :text => "2")
     end
     within "#appliedParams" do
       expect(page).to have_content "You searched for:"
       expect(page).to have_content "history"
     end
   end
+  it "should be collapsed when not selected", :js => true do
+    pending("Test passes locally but not on Travis.")
+    visit root_path
+    within(".blacklight-subject_topic_facet") do
+      expect(page).not_to have_selector(".panel-collapse", :visible => true)
+    end
+  end
+  it "should expand when the heading is clicked", :js => true do
+    pending("Test passes locally but not on Travis.")
+    visit root_path
+    within(".blacklight-subject_topic_facet") do
+      expect(page).not_to have_selector(".panel-collapse", :visible => true)
+      find(".panel-heading").click
+      expect(page).to     have_selector(".panel-collapse", :visible => true)
+    end
+  end
+  it "should expand when the anchor is clicked", :js => true do
+    pending("Test passes locally but not on Travis.")
+    visit root_path
+    within(".blacklight-subject_topic_facet") do
+      expect(page).not_to have_selector(".panel-collapse", :visible => true)
+      click_link "Topic"
+      expect(page).to     have_selector(".panel-collapse", :visible => true)
+    end
+  end
+  it "should keep selected facets expanded on page load", :js => true do
+    pending("Test passes locally but not on Travis.")
+    visit root_path
+    within(".blacklight-subject_topic_facet") do
+      click_link "Topic"
+      expect(page).to have_selector(".panel-collapse", :visible => true)
+      click_link "Japanese drama"
+    end
+    within(".blacklight-subject_topic_facet") do
+      expect(page).to have_selector(".panel-collapse", :visible => true)
+    end
+  end
 end

data/spec/features/search_results_spec.rb

@@ -4,34 +4,34 @@ require 'spec_helper'
 describe "Search Results" do
   it "should have for an empty query" do
     search_for ''
-    expect(number_of_results_from_page(page)).to eq(30)
-    expect(page).to have_xpath("//a[contains(@href, #{2007020969})]")
+    number_of_results_from_page(page).should == 30
+    page.should have_xpath("//a[contains(@href, #{2007020969})]")
     search_for 'korea'
-    expect(number_of_results_from_page(page)).to eq(4)
+    number_of_results_from_page(page).should == 4
   end
 
   it "should find same result set with or without diacritcs" do
     search_for 'inmul'
-    expect(number_of_results_from_page(page)).to eq(1)
-    expect(page).to have_xpath("//a[contains(@href, #{77826928})]")
+    number_of_results_from_page(page).should == 1
+    page.should have_xpath("//a[contains(@href, #{77826928})]")
 
     search_for 'inmül'
-    expect(number_of_results_from_page(page)).to eq(1)
+    number_of_results_from_page(page).should == 1
   end
   it "should find same result set for a case-insensitive query " do
     search_for 'inmul'
-    expect(number_of_results_from_page(page)).to eq(1)
-    expect(page).to have_xpath("//a[contains(@href, #{77826928})]")
+    number_of_results_from_page(page).should == 1
+    page.should have_xpath("//a[contains(@href, #{77826928})]")
 
     search_for 'INMUL'
-    expect(number_of_results_from_page(page)).to eq(1)
+    number_of_results_from_page(page).should == 1
   end
 
   it "should order by relevancy" do
     search_for "Korea"
-    expect(position_in_result_page(page, '77826928')).to eq(1)
-    expect(position_in_result_page(page, '94120425')).to eq(2)
-
+    position_in_result_page(page, '77826928').should == 1
+    position_in_result_page(page, '94120425').should == 2
+    
   end
 
   it "should have an opensearch description document" do
@@ -49,10 +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'
+    search_for ''
     search_id =  Search.last.id.to_s
     click_on 'Pluvial nectar of blessings'
     expect(page).to have_content "« Previous | 10 of 30 | Next »"
@@ -83,7 +80,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

data/spec/features/search_sort_spec.rb

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

data/spec/helpers/blacklight_helper_spec.rb

@@ -1,4 +1,3 @@
-#ste -*- encoding : utf-8 -*-
 # -*- coding: UTF-8 -*-
 require 'spec_helper'
 
@@ -82,7 +81,7 @@ describe BlacklightHelper do
   end
 
   before(:each) do
-    allow(helper).to receive(:search_action_url) do |*args|
+    helper.stub(:search_action_url) do |*args|
       catalog_index_url *args
     end
   end
@@ -91,221 +90,157 @@ describe BlacklightHelper do
 
   end
 
-  describe "deprecated methods" do
-    describe "#index_field_names" do
-      it "should warn" do
-        expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        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)
-        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)
-        allow(helper).to receive_messages(:document_show_fields => {})
-        helper.document_show_field_labels
-      end
-    end
-
-    describe "#render_document_list_partial" do
-      it "should warn" do
-        expect(Blacklight::BlacklightHelperBehavior.deprecation_behavior.first).to receive(:call)
-        allow(helper).to receive(:render)
-        helper.render_document_list_partial
-      end
-    end
-  end
-
   describe "#application_name", :test => true do
     it "should use the Rails application config application_name if available" do
-      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')
+      Rails.application.config.stub(:application_name => 'asdf')
+      Rails.application.config.should_receive(:respond_to?).with(:application_name).and_return(true)
+      application_name.should == 'asdf'
     end
     it "should default to 'Blacklight'" do
-      expect(application_name).to eq("Blacklight")
+      application_name.should == "Blacklight"
     end
   end
 
   describe "link_back_to_catalog" do
-    before(:all) do
-      @query_params = {:q => "query", :f => "facets", :per_page => "10", :page => "2", :controller=>'catalog'}
-      @bookmarks_query_params = { :page => "2", :controller=>'bookmarks'}
-    end
+    let(:query_params)  {{:q => "query", :f => "facets", :per_page => "10", :page => "2", :controller=>'catalog'}}
+    let(:bookmarks_query_params) {{ :page => "2", :controller=>'bookmarks'}}
 
     it "should build a link tag to catalog using session[:search] for query params" do
-      allow(helper).to receive(:current_search_session).and_return double(:query_params => @query_params)
+      helper.stub(:current_search_session).and_return double(:query_params => query_params)
       tag = helper.link_back_to_catalog
-      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/)
+      tag.should =~ /q=query/
+      tag.should =~ /f=facets/
+      tag.should =~ /per_page=10/
+      tag.should =~ /page=2/
     end
 
     it "should build a link tag to bookmarks using session[:search] for query params" do
-      allow(helper).to receive(:current_search_session).and_return double(:query_params => @bookmarks_query_params)
+      helper.stub(:current_search_session).and_return double(:query_params => bookmarks_query_params)
       tag = helper.link_back_to_catalog
-      expect(tag).to match(/Back to Bookmarks/)
-      expect(tag).to match(/\/bookmarks/)
-      expect(tag).to match(/page=2/)
+      tag.should =~ /Back to Bookmarks/
+      tag.should =~ /\/bookmarks/
+      tag.should =~ /page=2/
+    end
+
+    describe "when an alternate scope is passed in" do
+      let(:my_engine) { double("Engine") }
+
+      it "should call url_for on the engine scope" do
+        helper.stub(:current_search_session).and_return double(:query_params => query_params)
+        expect(my_engine).to receive(:url_for).and_return(url_for(query_params))
+        tag = helper.link_back_to_catalog(route_set: my_engine)
+        tag.should =~ /Back to Search/
+        tag.should =~ /q=query/
+        tag.should =~ /f=facets/
+        tag.should =~ /per_page=10/
+        tag.should =~ /page=2/
+      end
     end
   end
 
   describe "link_to_query" do
     it "should build a link tag to catalog using query string (no other params)" do
       query = "brilliant"
-      expect(self).to receive(:params).and_return({})
+      self.should_receive(:params).and_return({})
       tag = link_to_query(query)
-      expect(tag).to match(/q=#{query}/)
-      expect(tag).to match(/>#{query}<\/a>/)
+      tag.should =~ /q=#{query}/
+      tag.should =~ />#{query}<\/a>/
     end
     it "should build a link tag to catalog using query string and other existing params" do
       query = "wonderful"
-      expect(self).to receive(:params).and_return({:qt => "title_search", :per_page => "50"})
+      self.should_receive(:params).and_return({:qt => "title_search", :per_page => "50"})
       tag = link_to_query(query)
-      expect(tag).to match(/qt=title_search/)
-      expect(tag).to match(/per_page=50/)
+      tag.should =~ /qt=title_search/
+      tag.should =~ /per_page=50/
     end
     it "should ignore existing :page param" do
       query = "yes"
-      expect(self).to receive(:params).and_return({:page => "2", :qt => "author_search"})
+      self.should_receive(:params).and_return({:page => "2", :qt => "author_search"})
       tag = link_to_query(query)
-      expect(tag).to match(/qt=author_search/)
-      expect(tag).not_to match(/page/)
+      tag.should =~ /qt=author_search/
+      tag.should_not =~ /page/
     end
     it "should be html_safe" do
       query = "brilliant"
-      expect(self).to receive(:params).and_return({:page => "2", :qt => "author_search"})
+      self.should_receive(:params).and_return({:page => "2", :qt => "author_search"})
       tag = link_to_query(query)
-      expect(tag.html_safe?).to eq(true)
-    end
-  end
-
-  describe "sanitize_search_params" do
-    it "should strip nil values" do
-      result = sanitize_search_params(:a => nil, :b => 1)
-      expect(result).to_not have_key(:a)
-      expect(result[:b]).to eq 1
-    end
-
-    it "should remove blacklisted keys" do
-      result = sanitize_search_params(:action => true, :controller => true, :id => true, :commit => true, :utf8 => true)
-      expect(result).to be_empty
+      tag.html_safe?.should == true
     end
   end
 
   describe "params_for_search" do
-    around(:each) do |example|
-      Deprecation.silence(Blacklight::BlacklightHelperBehavior) { example.run }
-    end
-
     def params
       { 'default' => 'params'}
     end
 
     it "should default to using the controller's params" do
       result = params_for_search
-      expect(result).to eq(params)
-      expect(params.object_id).not_to eq(result.object_id)
+      result.should == params
+      params.object_id.should_not == result.object_id
     end
 
     it "should let you pass in params to use" do
-      source_params = { :q => 'query'}
-      result = params_for_search(source_params, {})
-      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 )
-      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'}
-      result = params_for_search( source_params )
-      expect(result).to include(:q => 'query', 'default' => 'params')
+      source_params.should == result
+      source_params.object_id.should_not == result.object_id
     end
 
     it "should not return blacklisted elements" do
       source_params = { :action => 'action', :controller => 'controller', :id => "id", :commit => 'commit'}
-      result = params_for_search(source_params, {} )
-      expect(result.keys).not_to include(:action, :controller, :commit, :id)
+      result = params_for_search(:params => source_params )
+      result.keys.should_not 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)
-      expect(result[:page]).to eq(1)
+      result = params_for_search(:params => source_params, :per_page => 100)
+      result[:page].should == 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)
-      expect(result[:page]).to eq(5)
+      result = params_for_search(:params => source_params, :per_page => 20)
+      result[:page].should == 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')
-      expect(result[:page]).to eq(1)
+      result = params_for_search(:params => source_params, :sort => 'field_b')
+      result[:page].should == 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')
-      expect(result[:page]).to eq(5)
+      result = params_for_search(:params => source_params, :sort => 'field_a')
+      result[:page].should == 5
     end
 
     describe "omit keys parameter" do
       it "should omit keys by key name" do
         source_params = { :a => 1, :b => 2, :c => 3}
-        result = params_for_search(source_params, :omit_keys => [:a, :b] )
+        result = params_for_search(:params => source_params, :omit_keys => [:a, :b] )
 
-        expect(result.keys).not_to include(:a, :b)
-        expect(result[:c]).to eq(3)
+        result.keys.should_not include(:a, :b)
+        result[:c].should == 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' }])
-        expect(result.keys).not_to include(:f)
+        result = params_for_search(:params => source_params, :omit_keys => [{:f => 'a' }])
+        result.keys.should_not 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' }])
-        expect(result[:f]).not_to include('a')
-        expect(result[:f]).to include('b')
+        result = params_for_search(:params => source_params, :omit_keys => [{:f => 'a' }])
+        result[:f].should_not include('a')
+        result[:f].should 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[:d] = 'd'
-        end
-
-        expect(result.keys).not_to include(:a, :b)
-        expect(result[:c]).to eq 3
-        expect(result[:d]).to eq 'd'
-      end
-
-    end
-
   end
 
   describe "search_as_hidden_fields" do
@@ -314,9 +249,7 @@ describe BlacklightHelper do
     end
     describe "for default arguments" do
       it "should default to omitting :page" do
-        Deprecation.silence(Blacklight::BlacklightHelperBehavior) do
-          expect(search_as_hidden_fields).not_to have_selector("input[name='page']")
-        end
+        search_as_hidden_fields.should_not have_selector("input[name='page']")
       end
     end
  end
@@ -325,18 +258,18 @@ describe BlacklightHelper do
    describe "render body class" do
       it "should include a serialization of the current controller name" do
         @controller = double("controller")
-        allow(@controller).to receive(:controller_name).and_return("123456")
-        allow(@controller).to receive(:action_name).and_return("abcdef")
+        @controller.stub(:controller_name).and_return("123456")
+        @controller.stub(:action_name).and_return("abcdef")
 
-	expect(render_body_class.split(' ')).to include('blacklight-123456')
+	render_body_class.split(' ').should include('blacklight-123456')
       end
 
       it "should include a serialization of the current action name" do
         @controller = double("controller")
-        allow(@controller).to receive(:controller_name).and_return("123456")
-        allow(@controller).to receive(:action_name).and_return("abcdef")
+        @controller.stub(:controller_name).and_return("123456")
+        @controller.stub(:action_name).and_return("abcdef")
 
-	expect(render_body_class.split(' ')).to include('blacklight-123456-abcdef')
+	render_body_class.split(' ').should include('blacklight-123456-abcdef')
       end
    end
 
@@ -345,12 +278,12 @@ describe BlacklightHelper do
      it "should consist of the show heading field when available" do
       @document = SolrDocument.new('title_display' => "A Fake Document")
 
-      expect(document_heading).to eq("A Fake Document")
+      document_heading.should == "A Fake Document"
      end
 
      it "should fallback on the document id if no title is available" do
        @document = SolrDocument.new(:id => '123456')
-       expect(document_heading).to eq('123456')
+       document_heading.should == '123456'
      end
    end
 
@@ -358,97 +291,77 @@ describe BlacklightHelper do
      it "should consist of #document_heading wrapped in a <h1>" do
       @document = SolrDocument.new('title_display' => "A Fake Document")
 
-      expect(render_document_heading).to have_selector("h4", :text => "A Fake Document", :count => 1)
-      expect(render_document_heading.html_safe?).to eq(true)
+      render_document_heading.should have_selector("h4", :text => "A Fake Document", :count => 1)
+      render_document_heading.html_safe?.should == true
      end
      it "should join the values if it is an array" do
       @document = SolrDocument.new('title_display' => ["A Fake Document", 'Something Else'])
 
-      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)
+      render_document_heading.should have_selector("h4", :text => "A Fake Document, Something Else", :count => 1)
+      render_document_heading.html_safe?.should == 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'])
-      expect(document_show_html_title).to eq("A Fake Document, Something Else")
+      document_show_html_title.should == "A Fake Document, Something Else"
      end
    end
 
    describe "document_index_view_type" do
      it "should default to 'list'" do
-       expect(document_index_view_type).to eq('list')
+       document_index_view_type.should == 'list'
      end
 
      it "should pluck values out of params" do
-       allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'asdf'] }
+       blacklight_config.stub(:document_index_view_types) { ['list', 'asdf'] }
        params[:view] = 'asdf'
-       expect(document_index_view_type).to eq('asdf')
+       document_index_view_type.should == 'asdf'
 
        params[:view] = 'not_in_list'
-       expect(document_index_view_type).to eq('list')
-     end
-
-     it "should pluck values from supplied params" do
-       allow(blacklight_config).to receive(:document_index_view_types) { ['list', 'asdf'] }
-       params[:view] = 'asdf'
-       expect(document_index_view_type(:view => 'list')).to eq 'list'
+       document_index_view_type.should == 'list'
      end
    end
 
-   describe "start_over_path" do
-    it 'should be the catalog path with the current view type' do
-      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
-      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
-
    describe "render_document_index" do
      it "should render the document_list" do
        @document_list = ['a', 'b']
-       expect(self).to receive(:render).with(hash_including(:partial => 'document_gallery'))
+       self.should_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 [], '', '', '',''
-       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'))
+       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'))
        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
-       expect(document_partial_name({})).to eq("default")
+       document_partial_name({}).should == "default"
      end
      it "should handle normal formats correctly" do
-       expect(document_partial_name({"format" => "myformat"})).to eq("myformat")
+       document_partial_name({"format" => "myformat"}).should == "myformat"
      end
      it "should handle spaces correctly" do
-       expect(document_partial_name({"format" => "my format"})).to eq("my_format")
+       document_partial_name({"format" => "my format"}).should == "my_format"
      end
      it "should handle capitalization correctly" do
-       expect(document_partial_name({"format" => "MyFormat"})).to eq("myformat")
+       document_partial_name({"format" => "MyFormat"}).should == "myformat"
      end
      it "should handle puncuation correctly" do
-       expect(document_partial_name({"format" => "My.Format"})).to eq("my_format")
+       document_partial_name({"format" => "My.Format"}).should == "my_format"
      end
      it "should handle multi-valued fields correctly" do
-       expect(document_partial_name({"format" => ["My Format", "My OtherFormat"]})).to eq("my_format_my_otherformat")
+       document_partial_name({"format" => ["My Format", "My OtherFormat"]}).should == "my_format_my_otherformat"
      end
      it "should remove - characters because they will throw errors" do
-       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")
+       document_partial_name({"format" => "My-Format"}).should == "my_format"
+       document_partial_name({"format" => ["My-Format",["My Other-Format"]]}).should == "my_format_my_other_format"
      end
    end
 
@@ -456,45 +369,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)
-      expect(link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '654321', :count => 1)
+      link_to_document(@document, { :label => :title_display }).should 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)
-      expect(link_to_document(@document, { :label => "title_display" })).to have_selector("a", :text => 'title_display', :count => 1)
+      link_to_document(@document, { :label => "title_display" }).should 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)
-      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)
+      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)
      end
      it "should return id when label is missing" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      expect(link_to_document(@document, { :label => :title_display })).to have_selector("a", :text => '123456', :count => 1)
+      link_to_document(@document, { :label => :title_display }).should have_selector("a", :text => '123456', :count => 1)
      end
 
      it "should be html safe" do
       data = {'id'=>'123456'}
       @document = SolrDocument.new(data)
-      expect(link_to_document(@document, { :label => :title_display }).html_safe?).to eq(true)
+      link_to_document(@document, { :label => :title_display }).html_safe?.should == true
      end
 
      it "should convert the counter parameter into a data- attribute" do
       data = {'id'=>'123456','title_display'=>['654321']}
       @document = SolrDocument.new(data)
-      expect(link_to_document(@document, { :label => :title_display, :counter => 5  })).to match(/data-counter="5"/)
+      link_to_document(@document, { :label => :title_display, :counter => 5  }).should =~ /data-counter="5"/
      end
 
      it "passes on the title attribute to the link_to_with_data method" do
        @document = SolrDocument.new('id'=>'123456')
-       expect(link_to_document(@document,:label=>"Some crazy long label...",:title=>"Some crazy longer label")).to match(/title=\"Some crazy longer label\"/)
+       link_to_document(@document,:label=>"Some crazy long label...",:title=>"Some crazy longer label").should 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')
-       expect(link_to_document(@document,:label=>"Some crazy long label...")).not_to match(/title=/)
+       link_to_document(@document,:label=>"Some crazy long label...").should_not match(/title=/)
      end
    end
 
@@ -521,7 +434,7 @@ describe BlacklightHelper do
       @doc_id = "MOCK_ID1"
       @document = MockDocumentAppHelper.new(:id => @doc_id)
       render_params = {:controller => "controller", :action => "action"}
-      allow(helper).to receive(:params).and_return(render_params)
+      helper.stub(:params).and_return(render_params)
     end
     it "generates <link rel=alternate> tags" do
 
@@ -530,12 +443,12 @@ describe BlacklightHelper do
       tmp_value = Capybara.ignore_hidden_elements
       Capybara.ignore_hidden_elements = false
       @document.export_formats.each_pair do |format, spec|
-        expect(response).to have_selector("link[href$='.#{ format  }']") do |matches|
-          expect(matches.length).to eq(1)
+        response.should have_selector("link[href$='.#{ format  }']") do |matches|
+          matches.length.should == 1
           tag = matches[0]
-          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)
+          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)
         end
       end
       Capybara.ignore_hidden_elements = tmp_value
@@ -558,7 +471,7 @@ describe BlacklightHelper do
 
     it "should be html safe" do
       response = render_link_rel_alternates(@document)
-      expect(response.html_safe?).to eq(true)
+      response.html_safe?.should == true
     end
   end
 
@@ -574,20 +487,20 @@ describe BlacklightHelper do
       end
 
       @document = SolrDocument.new('title_display' => "A Fake Document", 'id'=>'8')
-      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)
+      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)
     end
     describe "render_index_doc_actions" do
       it "should render partials" do
         response = helper.render_index_doc_actions(@document)
-        expect(response).to have_selector(".bookmark_toggle")
+        response.should have_selector(".bookmark_toggle")
       end
     end
     describe "render_show_doc_actions" do
       it "should render partials" do
         response = helper.render_show_doc_actions(@document)
-        expect(response).to have_selector(".bookmark_toggle")
+        response.should have_selector(".bookmark_toggle")
       end
     end
   end
@@ -601,67 +514,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
-      allow(helper).to receive(:blacklight_config).and_return(@config)
+      helper.stub(:blacklight_config).and_return(@config)
     end
 
     it "should check for an explicit value" do
       doc = double()
-      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
+      doc.should_not_receive(:get).with('asdf', :sep => nil)
       value = helper.render_index_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      expect(value).to eq('asdf')
+      value.should == 'asdf'
     end
 
     it "should check for a helper method to call" do
       doc = double()
-      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
-      allow(helper).to receive(:render_asdf_index_field).and_return('custom asdf value')
+      doc.should_not_receive(:get).with('asdf', :sep => nil)
+      helper.stub(:render_asdf_index_field).and_return('custom asdf value')
       value = helper.render_index_field_value :document => doc, :field => 'asdf'
-      expect(value).to eq('custom asdf value')
+      value.should == 'custom asdf value'
     end
 
     it "should check for a link_to_search" do
       doc = double()
-      expect(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
+      doc.should_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'
-      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] })))
+      value.should == 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()
-      expect(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
+      doc.should_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'
-      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] })))
+      value.should == 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()
-      expect(doc).not_to receive(:get)
-      expect(doc).to receive(:has_highlight_field?).and_return(false)
+      doc.should_not_receive(:get)
+      doc.should_receive(:has_highlight_field?).and_return(false)
       value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      expect(value).to be_blank
+      value.should be_blank
     end
 
     it "should check for a highlighted field" do
       doc = double()
-      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])
+      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])
       value = helper.render_index_field_value :document => doc, :field => 'highlight'
-      expect(value).to eq('<em>highlight</em>')
+      value.should == '<em>highlight</em>'
     end
 
     it "should check the document field value" do
       doc = double()
-      expect(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
+      doc.should_receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
       value = helper.render_index_field_value :document => doc, :field => 'qwer'
-      expect(value).to eq('document qwer value')
+      value.should == 'document qwer value'
     end
 
     it "should work with index fields that aren't explicitly defined" do
       doc = double()
-      expect(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
+      doc.should_receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
       value = helper.render_index_field_value :document => doc, :field => 'mnbv'
-      expect(value).to eq('document mnbv value')
+      value.should == 'document mnbv value'
     end
   end
 
@@ -675,86 +588,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
-      allow(helper).to receive(:blacklight_config).and_return(@config)
+      helper.stub(:blacklight_config).and_return(@config)
     end
 
     it "should check for an explicit value" do
       doc = double()
-      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
-      expect(helper).not_to receive(:render_asdf_document_show_field)
+      doc.should_not_receive(:get).with('asdf', :sep => nil)
+      helper.should_not_receive(:render_asdf_document_show_field)
       value = helper.render_document_show_field_value :value => 'asdf', :document => doc, :field => 'asdf'
-      expect(value).to eq('asdf')
+      value.should == 'asdf'
     end
 
     it "should check for a helper method to call" do
       doc = double()
-      expect(doc).not_to receive(:get).with('asdf', :sep => nil)
-      allow(helper).to receive(:render_asdf_document_show_field).and_return('custom asdf value')
+      doc.should_not_receive(:get).with('asdf', :sep => nil)
+      helper.stub(:render_asdf_document_show_field).and_return('custom asdf value')
       value = helper.render_document_show_field_value :document => doc, :field => 'asdf'
-      expect(value).to eq('custom asdf value')
+      value.should == 'custom asdf value'
     end
 
     it "should check for a link_to_search" do
       doc = double()
-      expect(doc).to receive(:get).with('link_to_search_true', :sep => nil).and_return('x')
+      doc.should_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'
-      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :link_to_search_true => ['x'] })))
+      value.should == 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()
-      expect(doc).to receive(:get).with('link_to_search_named', :sep => nil).and_return('x')
+      doc.should_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'
-      expect(value).to eq(helper.link_to("x", helper.search_action_url(:f => { :some_field => ['x'] })))
+      value.should == 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()
-      expect(doc).not_to receive(:get)
-      expect(doc).to receive(:has_highlight_field?).and_return(false)
+      doc.should_not_receive(:get)
+      doc.should_receive(:has_highlight_field?).and_return(false)
       value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      expect(value).to be_blank
+      value.should be_blank
     end
 
     it "should check for a highlighted field" do
       doc = double()
-      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])
+      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])
       value = helper.render_document_show_field_value :document => doc, :field => 'highlight'
-      expect(value).to eq('<em>highlight</em>')
+      value.should == '<em>highlight</em>'
     end
 
 
     it "should check the document field value" do
       doc = double()
-      expect(doc).to receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
+      doc.should_receive(:get).with('qwer', :sep => nil).and_return('document qwer value')
       value = helper.render_document_show_field_value :document => doc, :field => 'qwer'
-      expect(value).to eq('document qwer value')
+      value.should == 'document qwer value'
     end
 
     it "should work with show fields that aren't explicitly defined" do
       doc = double()
-      expect(doc).to receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
+      doc.should_receive(:get).with('mnbv', :sep => nil).and_return('document mnbv value')
       value = helper.render_document_show_field_value :document => doc, :field => 'mnbv'
-      expect(value).to eq('document mnbv value')
+      value.should == 'document mnbv value'
     end
   end
 
   describe "#should_render_index_field?" do
     it "should if the document has the field value" do
       doc = double()
-      allow(doc).to receive(:has?).with('asdf').and_return(true)
+      doc.stub(:has?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf')
-      expect(helper.should_render_index_field?(doc, field_config)).to eq(true)
+      helper.should_render_index_field?(doc, field_config).should == true
     end
 
     it "should if the document has a highlight field value" do
       doc = double()
-      allow(doc).to receive(:has?).with('asdf').and_return(false)
-      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
+      doc.stub(:has?).with('asdf').and_return(false)
+      doc.stub(:has_highlight_field?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf', :highlight => true)
-      expect(helper.should_render_index_field?(doc, field_config)).to eq(true)
+      helper.should_render_index_field?(doc, field_config).should == true
     end
   end
 
@@ -762,17 +675,17 @@ describe BlacklightHelper do
   describe "#should_render_show_field?" do
     it "should if the document has the field value" do
       doc = double()
-      allow(doc).to receive(:has?).with('asdf').and_return(true)
+      doc.stub(:has?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf')
-      expect(helper.should_render_show_field?(doc, field_config)).to eq(true)
+      helper.should_render_show_field?(doc, field_config).should == true
     end
 
     it "should if the document has a highlight field value" do
       doc = double()
-      allow(doc).to receive(:has?).with('asdf').and_return(false)
-      allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
+      doc.stub(:has?).with('asdf').and_return(false)
+      doc.stub(:has_highlight_field?).with('asdf').and_return(true)
       field_config = double(:field => 'asdf', :highlight => true)
-      expect(helper.should_render_show_field?(doc, field_config)).to eq(true)
+      helper.should_render_show_field?(doc, field_config).should == true
     end
   end
 
@@ -780,13 +693,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 eq true
+      expect(helper.render_grouped_response?).to be_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 eq true
+      expect(helper.render_grouped_response?(response)).to be_true
     end
   end
 
@@ -800,7 +713,7 @@ describe BlacklightHelper do
     end
 
     it "should join values using the field_value_separator" do
-      allow(helper).to receive(:field_value_separator).and_return(" -- ")
+      helper.stub(:field_value_separator).and_return(" -- ")
       expect(helper.render_field_value(['a', 'b'])).to eq "a -- b"
     end
 
@@ -808,32 +721,4 @@ describe BlacklightHelper do
       expect(helper.render_field_value(['c', 'd'], double(:separator => '; '))).to eq "c; d"
     end
   end
-
-  describe "link_to_previous_search" do
-    it "should link to the given search parameters" do
-      params = {}
-      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
-      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 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 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 eq false
-    end
-  end
 end