blacklight 5.5.1 → 5.5.2

data/spec/helpers/catalog_helper_spec.rb

@@ -14,7 +14,7 @@ describe CatalogHelper do
     
     mock_response = Kaminari.paginate_array(mock_docs).page(current_page).per(per_page)
 
-    mock_response.stub(:docs).and_return(mock_docs.slice(start, per_page))
+    allow(mock_response).to receive(:docs).and_return(mock_docs.slice(start, per_page))
     mock_response
   end
 
@@ -62,7 +62,7 @@ describe CatalogHelper do
 
       it "should use the model_name from the response" do
         response = mock_response :total => 1
-        response.stub(:model_name).and_return(double(:human => 'thingy'))
+        allow(response).to receive(:model_name).and_return(double(:human => 'thingy'))
 
         html = page_entries_info(response)
         expect(html).to eq "<strong>1</strong> thingy found"
@@ -126,82 +126,82 @@ describe CatalogHelper do
 
   describe "should_autofocus_on_search_box?" do
     it "should be focused if we're on a catalog-like index page without query or facet parameters" do
-      helper.stub(controller: CatalogController.new, action_name: "index", has_search_parameters?: false)
-      expect(helper.should_autofocus_on_search_box?).to be_true
+      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: false)
+      expect(helper.should_autofocus_on_search_box?).to be true
     end
 
     it "should not be focused if we're not on a catalog controller" do
-      helper.stub(controller: ApplicationController.new)
-      expect(helper.should_autofocus_on_search_box?).to be_false
+      allow(helper).to receive_messages(controller: ApplicationController.new)
+      expect(helper.should_autofocus_on_search_box?).to be false
     end
 
     it "should not be focused if we're not on a catalog controller index" do
-      helper.stub(controller: CatalogController.new, action_name: "show")
-      expect(helper.should_autofocus_on_search_box?).to be_false
+      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "show")
+      expect(helper.should_autofocus_on_search_box?).to be false
     end
 
     it "should not be focused if a search parameters are provided" do
-      helper.stub(controller: CatalogController.new, action_name: "index", has_search_parameters?: true)
-      expect(helper.should_autofocus_on_search_box?).to be_false
+      allow(helper).to receive_messages(controller: CatalogController.new, action_name: "index", has_search_parameters?: true)
+      expect(helper.should_autofocus_on_search_box?).to be false
     end
   end
 
   describe "has_thumbnail?" do
     it "should have a thumbnail if a thumbnail_method is configured" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
       document = double()
-      expect(helper.has_thumbnail? document).to be_true
+      expect(helper.has_thumbnail? document).to be true
     end
 
     it "should have a thumbnail if a thumbnail_field is configured and it exists in the document" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
       document = double(:has? => true)
-      expect(helper.has_thumbnail? document).to be_true
+      expect(helper.has_thumbnail? document).to be true
     end
     
     it "should not have a thumbnail if the thumbnail_field is missing from the document" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
       document = double(:has? => false)
-      expect(helper.has_thumbnail? document).to be_false
+      expect(helper.has_thumbnail? document).to be false
     end
 
     it "should not have a thumbnail if none of the fields are configured" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
-      expect(helper.has_thumbnail? double()).to be_false
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
+      expect(helper.has_thumbnail? double()).to be_falsey
     end
   end
 
   describe "render_thumbnail_tag" do
     let(:document) { double }
     it "should call the provided thumbnail method" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      helper.stub(:xyz => "some-thumbnail")
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:xyz => "some-thumbnail")
 
-      helper.should_receive(:link_to_document).with(document, :label => "some-thumbnail")
+      allow(helper).to receive(:link_to_document).with(document, :label => "some-thumbnail")
       helper.render_thumbnail_tag document
     end
 
     it "should create an image tag from the given field" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
       
-      document.stub(:has?).with(:xyz).and_return(true)
-      document.stub(:first).with(:xyz).and_return("http://example.com/some.jpg")
+      allow(document).to receive(:has?).with(:xyz).and_return(true)
+      allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
 
-      helper.should_receive(:link_to_document).with(document, :label => image_tag("http://example.com/some.jpg"))
+      allow(helper).to receive(:link_to_document).with(document, :label => image_tag("http://example.com/some.jpg"))
       helper.render_thumbnail_tag document
     end
 
     it "should not link to the document if the url options are false" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      helper.stub(:xyz => "some-thumbnail")
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:xyz => "some-thumbnail")
 
       result = helper.render_thumbnail_tag document, {}, false
       expect(result).to eq "some-thumbnail"
     end
 
     it "should not link to the document if the url options have :suppress_link" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      helper.stub(:xyz => "some-thumbnail")
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:xyz => "some-thumbnail")
 
       result = helper.render_thumbnail_tag document, {}, suppress_link: true
       expect(result).to eq "some-thumbnail"
@@ -209,13 +209,13 @@ describe CatalogHelper do
     
 
     it "should return nil if no thumbnail is available" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
       expect(helper.render_thumbnail_tag document).to be_nil
     end
 
     it "should return nil if no thumbnail is returned from the thumbnail method" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      helper.stub(:xyz => nil)
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:xyz => nil)
       
       expect(helper.render_thumbnail_tag document).to be_nil
     end
@@ -223,17 +223,17 @@ describe CatalogHelper do
 
   describe "thumbnail_url" do
     it "should pull the configured thumbnail field out of the document" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
       document = double()
-      document.stub(:has?).with(:xyz).and_return(true)
-      document.stub(:first).with(:xyz).and_return("asdf")
+      allow(document).to receive(:has?).with(:xyz).and_return(true)
+      allow(document).to receive(:first).with(:xyz).and_return("asdf")
       expect(helper.thumbnail_url document).to eq("asdf")
     end
 
     it "should return nil if the thumbnail field doesn't exist" do
-      helper.stub(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
       document = double()
-      document.stub(:has?).with(:xyz).and_return(false)
+      allow(document).to receive(:has?).with(:xyz).and_return(false)
       expect(helper.thumbnail_url document).to be_nil
     end
   end

data/spec/helpers/configuration_helper_spec.rb

@@ -5,33 +5,33 @@ describe BlacklightConfigurationHelper do
   let(:config_value) { double() }
 
   before :each do
-    helper.stub(blacklight_config: blacklight_config)
+    allow(helper).to receive_messages(blacklight_config: blacklight_config)
   end
 
   describe "#index_fields" do
     it "should pass through the configuration" do
-      blacklight_config.stub(index_fields: config_value)
+      allow(blacklight_config).to receive_messages(index_fields: config_value)
       expect(helper.index_fields).to eq config_value
     end
   end
 
   describe "#sort_fields" do
     it "should convert the sort fields to select-ready values" do
-      blacklight_config.stub(sort_fields: { 'a' => double(key: 'a', label: 'a'), 'b' => double(key: 'b', label: 'b'), c: double(key: 'c', if: false)  })
+      allow(blacklight_config).to receive_messages(sort_fields: { 'a' => double(key: 'a', label: 'a'), 'b' => double(key: 'b', label: 'b'), c: double(key: 'c', if: false)  })
       expect(helper.sort_fields).to eq [['a', 'a'], ['b', 'b']]
     end
   end
 
   describe "#active_sort_fields" do
     it "should restrict the configured sort fields to only those that should be displayed" do
-      blacklight_config.stub(sort_fields: { a: double(if: false, unless: false), b: double(if:true, unless: true) })
+      allow(blacklight_config).to receive_messages(sort_fields: { a: double(if: false, unless: false), b: double(if:true, unless: true) })
       expect(helper.active_sort_fields).to be_empty
     end
   end
 
   describe "#document_show_fields" do
     it "should pass through the configuration" do
-      blacklight_config.stub(show_fields: config_value)
+      allow(blacklight_config).to receive_messages(show_fields: config_value)
       expect(helper.document_show_fields).to eq config_value
     end
   end
@@ -45,7 +45,7 @@ describe BlacklightConfigurationHelper do
     end
     
     it "should default to the first configured index view" do
-      blacklight_config.stub(view: { a: true, b: true})
+      allow(blacklight_config).to receive_messages(view: { a: true, b: true})
       expect(helper.default_document_index_view_type).to eq :a
     end
   end
@@ -58,17 +58,17 @@ describe BlacklightConfigurationHelper do
     end
 
     it "should filter views using :if/:unless configuration" do
-      helper.document_index_views.should have_key :list
-      helper.document_index_views.should_not have_key :abc
-      helper.document_index_views.should_not have_key :def
-      helper.document_index_views.should_not have_key :xyz
+      expect(helper.document_index_views).to have_key :list
+      expect(helper.document_index_views).to_not have_key :abc
+      expect(helper.document_index_views).to_not have_key :def
+      expect(helper.document_index_views).to_not have_key :xyz
     end
   end
 
   describe "#has_alternative_views?" do
     subject { helper.has_alternative_views?}
     describe "with a single view defined" do
-      it { should be_false }
+      it { should be false }
     end
 
     describe "with multiple views defined" do
@@ -77,13 +77,13 @@ describe BlacklightConfigurationHelper do
         blacklight_config.view.xyz
       end
 
-      it { should be_true }
+      it { should be true }
     end
   end
 
   describe "#spell_check_max" do
     it "should pass through the configuration" do
-      blacklight_config.stub(spell_max: config_value)
+      allow(blacklight_config).to receive_messages(spell_max: config_value)
       expect(helper.spell_check_max).to eq config_value
     end
   end
@@ -91,8 +91,8 @@ describe BlacklightConfigurationHelper do
   describe "#index_field_label" do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
-      helper.stub(:index_fields).and_return({ "my_field" => double(label: "some label") })
-      helper.should_receive(:solr_field_label).with("some label", :"blacklight.search.fields.index.my_field", :"blacklight.search.fields.my_field")
+      allow(helper).to receive(:index_fields).and_return({ "my_field" => double(label: "some label") })
+      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.index.my_field", :"blacklight.search.fields.my_field")
       helper.index_field_label document, "my_field"
     end
   end
@@ -100,8 +100,8 @@ describe BlacklightConfigurationHelper do
   describe "#document_show_field_label" do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
-      helper.stub(:document_show_fields).and_return({ "my_field" => double(label: "some label") })
-      helper.should_receive(:solr_field_label).with("some label", :"blacklight.search.fields.show.my_field", :"blacklight.search.fields.my_field")
+      allow(helper).to receive(:document_show_fields).and_return({ "my_field" => double(label: "some label") })
+      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.show.my_field", :"blacklight.search.fields.my_field")
       helper.document_show_field_label document, "my_field"
     end
   end
@@ -109,22 +109,22 @@ describe BlacklightConfigurationHelper do
   describe "#facet_field_label" do
     let(:document) { double }
     it "should look up the label to display for the given document and field" do
-      blacklight_config.stub(:facet_fields).and_return({ "my_field" => double(label: "some label") })
-      helper.should_receive(:solr_field_label).with("some label", :"blacklight.search.fields.facet.my_field", :"blacklight.search.fields.my_field")
+      allow(blacklight_config).to receive(:facet_fields).and_return({ "my_field" => double(label: "some label") })
+      allow(helper).to receive(:solr_field_label).with("some label", :"blacklight.search.fields.facet.my_field", :"blacklight.search.fields.my_field")
       helper.facet_field_label "my_field"
     end
   end
 
   describe "#solr_field_label" do
     it "should look up the label as an i18n string" do
-      helper.should_receive(:t).with(:some_key).and_return "my label"
+      allow(helper).to receive(:t).with(:some_key).and_return "my label"
       label = helper.solr_field_label :some_key
 
       expect(label).to eq "my label"
     end
 
     it "should pass the provided i18n keys to I18n.t" do
-      helper.should_receive(:t).with(:key_a, default: [:key_b, "default text"])
+      allow(helper).to receive(:t).with(:key_a, default: [:key_b, "default text"])
 
       label = helper.solr_field_label "default text", :key_a, :key_b
     end
@@ -132,31 +132,31 @@ describe BlacklightConfigurationHelper do
   
   describe "#default_per_page" do
     it "should be the configured default per page" do
-      helper.stub(blacklight_config: double(default_per_page: 42))
+      allow(helper).to receive_messages(blacklight_config: double(default_per_page: 42))
       expect(helper.default_per_page).to eq 42
     end
     
     it "should be the first per-page value if a default isn't set" do
-      helper.stub(blacklight_config: double(default_per_page: nil, per_page: [11, 22]))
+      allow(helper).to receive_messages(blacklight_config: double(default_per_page: nil, per_page: [11, 22]))
       expect(helper.default_per_page).to eq 11
     end
   end
   
   describe "#default_sort_field" do
     it "should be the configured default field" do
-      helper.stub(blacklight_config: double(sort_fields: { a: double(default: nil), b: double(key: 'b', default: true) }))
+      allow(helper).to receive_messages(blacklight_config: double(sort_fields: { a: double(default: nil), b: double(key: 'b', default: true) }))
       expect(helper.default_sort_field.key).to eq 'b'
     end
     
     it "should be the first per-page value if a default isn't set" do
-      helper.stub(blacklight_config: double(sort_fields: { a: double(key: 'a', default: nil), b: double(key: 'b', default: nil) }))
+      allow(helper).to receive_messages(blacklight_config: double(sort_fields: { a: double(key: 'a', default: nil), b: double(key: 'b', default: nil) }))
       expect(helper.default_sort_field.key).to eq 'a'
     end
   end
   
   describe "#per_page_options_for_select" do
     it "should be the per-page values formatted as options_for_select" do
-      helper.stub(blacklight_config: double(per_page: [11, 22, 33]))
+      allow(helper).to receive_messages(blacklight_config: double(per_page: [11, 22, 33]))
       expect(helper.per_page_options_for_select).to include ["11<span class=\"sr-only\"> per page</span>", 11]
       expect(helper.per_page_options_for_select).to include ["22<span class=\"sr-only\"> per page</span>", 22]
       expect(helper.per_page_options_for_select).to include ["33<span class=\"sr-only\"> per page</span>", 33]
@@ -167,21 +167,21 @@ describe BlacklightConfigurationHelper do
     let(:field_config) { double('field config', if: true, unless: false) }
     
     before do
-      helper.stub(document_has_value?: true)
+      allow(helper).to receive_messages(document_has_value?: true)
     end
 
     it "should be true" do
-      expect(helper.should_render_field?(field_config)).to be_true
+      expect(helper.should_render_field?(field_config)).to be true
     end
     
     it "should be false if the :if condition is false" do
-      field_config.stub(if: false)
-      expect(helper.should_render_field?(field_config)).to be_false
+      allow(field_config).to receive_messages(if: false)
+      expect(helper.should_render_field?(field_config)).to be false
     end
     
     it "should be false if the :unless condition is true" do
-      field_config.stub(unless: true)
-      expect(helper.should_render_field?(field_config)).to be_false
+      allow(field_config).to receive_messages(unless: true)
+      expect(helper.should_render_field?(field_config)).to be false
     end
   end
   
@@ -192,21 +192,21 @@ describe BlacklightConfigurationHelper do
     end
 
     it "should execute a helper method" do
-      helper.stub(:my_helper => true)
-      expect(helper.evaluate_configuration_conditional(:my_helper)).to be_true
+      allow(helper).to receive_messages(:my_helper => true)
+      expect(helper.evaluate_configuration_conditional(:my_helper)).to be true
     end
 
     it "should call a helper to determine if it should render a field" do
       a = double
-      helper.should_receive(:my_helper_with_an_arg).with(a).and_return(true)
-      expect(helper.evaluate_configuration_conditional(:my_helper_with_an_arg, a)).to be_true
+      allow(helper).to receive(:my_helper_with_an_arg).with(a).and_return(true)
+      expect(helper.evaluate_configuration_conditional(:my_helper_with_an_arg, a)).to be true
     end
 
     it "should evaluate a Proc to determine if it should render a field" do
       one_arg_lambda = lambda { |context, a| true }
       two_arg_lambda = lambda { |context, a, b| true }
-      expect(helper.evaluate_configuration_conditional(one_arg_lambda, 1)).to be_true
-      expect(helper.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be_true
+      expect(helper.evaluate_configuration_conditional(one_arg_lambda, 1)).to be true
+      expect(helper.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be true
     end
   end
   
@@ -224,7 +224,7 @@ describe BlacklightConfigurationHelper do
         config.add_search_field 'no_display', :qt => 'something', :include_in_simple_select => false
       end
 
-      helper.stub(blacklight_config: @config)
+      allow(helper).to receive_messages(blacklight_config: @config)
     end
     
     it "should return proper options_for_select arguments" do

data/spec/helpers/facets_helper_spec.rb

@@ -6,7 +6,7 @@ describe FacetsHelper do
   let(:blacklight_config) { Blacklight::Configuration.new }
 
   before(:each) do
-    helper.stub(:blacklight_config).and_return blacklight_config
+    allow(helper).to receive(:blacklight_config).and_return blacklight_config
   end
   
   describe "has_facet_values?" do
@@ -40,7 +40,7 @@ describe FacetsHelper do
         config.add_facet_field 'lambda_no_show', :show => lambda { |context, config, field| false }
       end
 
-      helper.stub(:blacklight_config => @config)
+      allow(helper).to receive_messages(:blacklight_config => @config)
     end
 
     it "should render facets with items" do
@@ -58,14 +58,14 @@ describe FacetsHelper do
     end
 
     it "should call a helper to determine if it should render a field" do
-      helper.stub(:my_helper => true)
+      allow(helper).to receive_messages(:my_helper => true)
       a = double(:items => [1,2], :name=>'helper_show')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "should call a helper to determine if it should render a field" do
       a = double(:items => [1,2], :name=>'helper_with_an_arg_show')
-      helper.should_receive(:my_helper_with_an_arg).with(@config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
+      allow(helper).to receive(:my_helper_with_an_arg).with(@config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
       expect(helper.should_render_facet?(a)).to be true
     end
 
@@ -86,7 +86,7 @@ describe FacetsHelper do
         config.add_facet_field 'no_collapse', collapse: false
       end
 
-      helper.stub(blacklight_config: @config)
+      allow(helper).to receive_messages(blacklight_config: @config)
     end
 
     it "should be collapsed by default" do
@@ -109,18 +109,18 @@ describe FacetsHelper do
     it "should retrieve the facet from the response given a string" do
       facet_config = double(:query => nil)
       facet_field = double()
-      helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+      allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
       @response = double()
-      @response.should_receive(:facet_by_field_name).with('a').and_return(facet_field)
+      allow(@response).to receive(:facet_by_field_name).with('a').and_return(facet_field)
 
       expect(helper.facet_by_field_name('a')).to eq facet_field
     end
 
     it "should also work for facet query fields" do
       facet_config = double(:query => {})
-      helper.should_receive(:facet_configuration_for_field).with('a_query_facet_field').and_return(facet_config)
-      helper.should_receive(:create_rsolr_facet_field_response_for_query_facet_field).with('a_query_facet_field', facet_config)
+      allow(helper).to receive(:facet_configuration_for_field).with('a_query_facet_field').and_return(facet_config)
+      allow(helper).to receive(:create_rsolr_facet_field_response_for_query_facet_field).with('a_query_facet_field', facet_config)
 
       helper.facet_by_field_name 'a_query_facet_field'
     end
@@ -137,7 +137,7 @@ describe FacetsHelper do
       }
 
       before(:each) do
-        helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+        allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
         @response = double(:facet_queries => {
           'field:search' => 10,
@@ -149,7 +149,7 @@ describe FacetsHelper do
 
       it"should convert the query facets into a double RSolr FacetField" do
         field = helper.facet_by_field_name('my_query_facet_field')
-        field.should be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
 
         expect(field.name).to eq'my_query_facet_field'
         expect(field.items.size).to eq 2
@@ -169,14 +169,14 @@ describe FacetsHelper do
       }
 
       before(:each) do 
-        helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+        allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
       
         @response = double(:facet_pivot => { 'field_a,field_b' => [{:field => 'field_a', :value => 'a', :count => 10, :pivot => [{:field => 'field_b', :value => 'b', :count => 2}]}]})
       end
 
       it "should convert the pivot facet into a double RSolr FacetField" do
         field = helper.facet_by_field_name('my_pivot_facet_field')
-        field.should be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
 
         expect(field.name).to eq 'my_pivot_facet_field'
 
@@ -199,9 +199,9 @@ describe FacetsHelper do
 
       fields = [a,b,empty]
 
-      helper.should_receive(:render_facet_limit).with(a, {})
-      helper.should_receive(:render_facet_limit).with(b, {})
-      helper.should_receive(:render_facet_limit).with(empty, {})
+      allow(helper).to receive(:render_facet_limit).with(a, {})
+      allow(helper).to receive(:render_facet_limit).with(b, {})
+      allow(helper).to receive(:render_facet_limit).with(empty, {})
 
       helper.render_facet_partials fields
     end
@@ -209,10 +209,10 @@ describe FacetsHelper do
     it "should default to the configured facets" do
       a = double(:items => [1,2])
       b = double(:items => ['b','c'])
-      helper.should_receive(:facet_field_names) { [a,b] }
+      allow(helper).to receive(:facet_field_names) { [a,b] }
 
-      helper.should_receive(:render_facet_limit).with(a, {})
-      helper.should_receive(:render_facet_limit).with(b, {})
+      allow(helper).to receive(:render_facet_limit).with(a, {})
+      allow(helper).to receive(:render_facet_limit).with(b, {})
 
       helper.render_facet_partials
     end
@@ -229,13 +229,13 @@ describe FacetsHelper do
         config.add_facet_field 'my_facet_field_with_custom_partial', :partial => 'custom_facet_partial'
       end
 
-      helper.stub(:blacklight_config => @config)
+      allow(helper).to receive_messages(:blacklight_config => @config)
       @response = double()
     end
 
     it "should set basic local variables" do
       @mock_facet = double(:name => 'basic_field', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:partial => 'facet_limit', 
+      allow(helper).to receive(:render).with(hash_including(:partial => 'facet_limit', 
                                                          :locals => { 
                                                             :solr_field => 'basic_field',
                                                             :facet_field => helper.blacklight_config.facet_fields['basic_field'],
@@ -246,37 +246,37 @@ describe FacetsHelper do
 
     it "should render a facet _not_ declared in the configuration" do
       @mock_facet = double(:name => 'asdf', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:partial => 'facet_limit'))
+      allow(helper).to receive(:render).with(hash_including(:partial => 'facet_limit'))
       helper.render_facet_limit(@mock_facet)
     end
 
     it "should get the partial name from the configuration" do
       @mock_facet = double(:name => 'my_facet_field_with_custom_partial', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      allow(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
       helper.render_facet_limit(@mock_facet)
     end 
 
     it "should use a partial layout for rendering the facet frame" do
       @mock_facet = double(:name => 'my_facet_field_with_custom_partial', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:layout => 'facet_layout'))
+      allow(helper).to receive(:render).with(hash_including(:layout => 'facet_layout'))
       helper.render_facet_limit(@mock_facet)
     end
 
     it "should allow the caller to opt-out of facet layouts" do
       @mock_facet = double(:name => 'my_facet_field_with_custom_partial', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:layout => nil))
+      allow(helper).to receive(:render).with(hash_including(:layout => nil))
       helper.render_facet_limit(@mock_facet, :layout => nil)
     end
 
     it "should render the facet_pivot partial for pivot facets" do
       @mock_facet = double(:name => 'pivot_facet_field', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:partial => 'facet_pivot'))
+      allow(helper).to receive(:render).with(hash_including(:partial => 'facet_pivot'))
       helper.render_facet_limit(@mock_facet)
     end 
 
     it "should let you override the rendered partial for pivot facets" do
       @mock_facet = double(:name => 'my_pivot_facet_field_with_custom_partial', :items => [1,2,3])
-      helper.should_receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      allow(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
       helper.render_facet_limit(@mock_facet)
     end 
   end
@@ -312,7 +312,7 @@ describe FacetsHelper do
 
   describe "facet_field_in_params?" do
     it "should check if the facet field is selected in the user params" do
-      helper.stub(:params => { :f => { "some-field" => ["x"]}})
+      allow(helper).to receive_messages(:params => { :f => { "some-field" => ["x"]}})
       expect(helper.facet_field_in_params?("some-field")).to be_truthy
       expect(helper.facet_field_in_params?("other-field")).to_not be true
     end
@@ -325,9 +325,9 @@ describe FacetsHelper do
   describe "render_facet_value" do
     let (:item) { double(:value => 'A', :hits => 10) }
     before do
-      helper.stub(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false))
-      helper.should_receive(:facet_display_value).and_return('Z')
-      helper.should_receive(:add_facet_params_and_redirect).and_return({controller:'catalog'})
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false))
+      allow(helper).to receive(:facet_display_value).and_return('Z')
+      allow(helper).to receive(:add_facet_params_and_redirect).and_return({controller:'catalog'})
       
       allow(helper).to receive(:search_action_path) do |*args|
         catalog_index_path *args
@@ -352,30 +352,30 @@ describe FacetsHelper do
  
   describe "#facet_display_value" do
     it "should just be the facet value for an ordinary facet" do
-      helper.stub(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil))
       expect(helper.facet_display_value('simple_field', 'asdf')).to eq 'asdf'
     end
 
     it "should allow you to pass in a :helper_method argument to the configuration" do
-      helper.stub(:facet_configuration_for_field).with('helper_field').and_return(double(:query => nil, :date => nil, :helper_method => :my_facet_value_renderer))
+      allow(helper).to receive(:facet_configuration_for_field).with('helper_field').and_return(double(:query => nil, :date => nil, :helper_method => :my_facet_value_renderer))
     
-      helper.should_receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
+      allow(helper).to receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
 
       expect(helper.facet_display_value('helper_field', 'qwerty')).to eq 'abc'
     end
 
     it "should extract the configuration label for a query facet" do
-      helper.stub(:facet_configuration_for_field).with('query_facet').and_return(double(:query => { 'query_key' => { :label => 'XYZ'}}, :date => nil, :helper_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('query_facet').and_return(double(:query => { 'query_key' => { :label => 'XYZ'}}, :date => nil, :helper_method => nil))
       expect(helper.facet_display_value('query_facet', 'query_key')).to eq 'XYZ'
     end
 
     it "should localize the label for date-type facets" do
-      helper.stub(:facet_configuration_for_field).with('date_facet').and_return(double('date' => true, :query => nil, :helper_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => true, :query => nil, :helper_method => nil))
       expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq 'Sun, 01 Jan 2012 00:00:00 +0000'
     end
 
     it "should localize the label for date-type facets with the supplied localization options" do
-      helper.stub(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { :format => :short }, :query => nil, :helper_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { :format => :short }, :query => nil, :helper_method => nil))
       expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq '01 Jan 00:00'
     end
   end