blacklight 4.7.0 → 4.8.0

data/spec/helpers/catalog_helper_spec.rb

@@ -11,10 +11,10 @@ describe CatalogHelper do
     start = (current_page - 1) * per_page
 
     mock_docs = (1..total).to_a.map { {}.with_indifferent_access }
-    
+
     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
 
@@ -27,10 +27,10 @@ describe CatalogHelper do
       it "should be deprecated" do
         expect(Blacklight::CatalogHelperBehavior.deprecation_behavior.first).to receive(:call)
         assign(:response, double(:empty? => false))
-        expect(helper.response_has_no_search_results?).to be_false
+        expect(helper.response_has_no_search_results?).to eq false
       end
     end
-    
+
     describe "paginate_params" do
       let(:response) { double }
       it "should be deprecated" do
@@ -48,7 +48,7 @@ describe CatalogHelper do
     end
 
   end
-  
+
   describe "page_entries_info" do
     before(:all) do
     end
@@ -57,16 +57,16 @@ describe CatalogHelper do
       @response = mock_response :total => 0
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      html.should == "No entry_names found"
-      html.html_safe?.should == true
+      expect(html).to eq("No entry_names found")
+      expect(html.html_safe?).to eq(true)
     end
 
     it "with no results (and no entry_name provided)" do
       @response = mock_response :total => 0
 
       html = page_entries_info(@response)
-      html.should == "No entries found"
-      html.html_safe?.should == true
+      expect(html).to eq("No entries found")
+      expect(html.html_safe?).to eq(true)
     end
 
     describe "with a single result" do
@@ -74,21 +74,21 @@ describe CatalogHelper do
         response = mock_response :total => 1
 
         html = page_entries_info(response, { :entry_name => 'entry_name' })
-        html.should == "<strong>1</strong> entry_name found"
-        html.html_safe?.should == true
+        expect(html).to eq("<strong>1</strong> entry_name found")
+        expect(html.html_safe?).to eq(true)
       end
 
       it "should infer a name" do
         response = mock_response :total => 1
 
         html = page_entries_info(response)
-        html.should == "<strong>1</strong> entry found"
-        html.html_safe?.should == true
+        expect(html).to eq("<strong>1</strong> entry found")
+        expect(html.html_safe?).to eq(true)
       end
 
       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"
@@ -100,46 +100,46 @@ describe CatalogHelper do
       response = mock_response :total => 7
 
       html = page_entries_info(response, { :entry_name => 'entry_name' })
-      html.should == "<strong>1</strong> - <strong>7</strong> of <strong>7</strong>"
-      html.html_safe?.should == true
+      expect(html).to eq("<strong>1</strong> - <strong>7</strong> of <strong>7</strong>")
+      expect(html.html_safe?).to eq(true)
     end
 
     it "on the first page of multiple pages of results" do
       @response = mock_response :total => 15, :per_page => 10
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      html.should == "<strong>1</strong> - <strong>10</strong> of <strong>15</strong>"
-      html.html_safe?.should == true
+      expect(html).to eq("<strong>1</strong> - <strong>10</strong> of <strong>15</strong>")
+      expect(html.html_safe?).to eq(true)
     end
 
     it "on the second page of multiple pages of results" do
       @response = mock_response :total => 47, :per_page => 10, :current_page => 2
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      html.should == "<strong>11</strong> - <strong>20</strong> of <strong>47</strong>"
-      html.html_safe?.should == true
+      expect(html).to eq("<strong>11</strong> - <strong>20</strong> of <strong>47</strong>")
+      expect(html.html_safe?).to eq(true)
     end
 
     it "on the last page of results" do
       @response = mock_response :total => 47, :per_page => 10, :current_page => 5
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      html.should == "<strong>41</strong> - <strong>47</strong> of <strong>47</strong>"
-      html.html_safe?.should == true
+      expect(html).to eq("<strong>41</strong> - <strong>47</strong> of <strong>47</strong>")
+      expect(html.html_safe?).to eq(true)
     end
     it "should work with rows the same as per_page" do
       @response = mock_response :total => 47, :rows => 20, :current_page => 2
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      html.should == "<strong>21</strong> - <strong>40</strong> of <strong>47</strong>"
-      html.html_safe?.should == true
+      expect(html).to eq("<strong>21</strong> - <strong>40</strong> of <strong>47</strong>")
+      expect(html.html_safe?).to eq(true)
     end
 
     it "uses delimiters with large numbers" do
       @response = mock_response :total => 5000, :rows => 10, :current_page => 101
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
 
-      html.should == "<strong>1,001</strong> - <strong>1,010</strong> of <strong>5,000</strong>"
+      expect(html).to eq("<strong>1,001</strong> - <strong>1,010</strong> of <strong>5,000</strong>")
     end
 
     it "should work with an activerecord collection" do
@@ -152,87 +152,87 @@ 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", :params => { })
-      expect(helper.should_autofocus_on_search_box?).to be_true
+      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "index", :params => { })
+      expect(helper.should_autofocus_on_search_box?).to eq 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 eq 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 eq false
     end
 
     it "should not be focused if a search string is provided" do
-      helper.stub(:controller => CatalogController.new, :action_name => "index", :params => { :q => "hello"})
-      expect(helper.should_autofocus_on_search_box?).to be_false
+      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "index", :params => { :q => "hello"})
+      expect(helper.should_autofocus_on_search_box?).to eq false
     end
 
     it "should not be focused if a facet is selected" do
-      helper.stub(:controller => CatalogController.new, :action_name => "index", :params => { :f => { "field" => ["value"]}})
-      expect(helper.should_autofocus_on_search_box?).to be_false
+      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "index", :params => { :f => { "field" => ["value"]}})
+      expect(helper.should_autofocus_on_search_box?).to eq false
     end
   end
 
   describe "has_thumbnail?" do
     it "should have a thumbnail if a thumbnail_method is configured" do
-      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_method => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_method => :xyz) ))
       document = double()
-      expect(helper.has_thumbnail? document).to be_true
+      expect(helper.has_thumbnail? document).to be_truthy
     end
 
     it "should have a thumbnail if a thumbnail_field is configured and it exists in the document" do
-      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
       document = double(:has? => true)
-      expect(helper.has_thumbnail? document).to be_true
+      expect(helper.has_thumbnail? document).to be_truthy
     end
-    
+
     it "should not have a thumbnail if the thumbnail_field is missing from the document" do
-      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
       document = double(:has? => false)
-      expect(helper.has_thumbnail? document).to be_false
+      expect(helper.has_thumbnail? document).to eq false
     end
 
     it "should not have a thumbnail if none of the fields are configured" do
-      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new()))
-      expect(helper.has_thumbnail? double()).to be_false
+      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new()))
+      expect(helper.has_thumbnail? double()).to be_falsey
     end
   end
 
   describe "render_thumbnail_tag" do
     it "should call the provided thumbnail method" do
-      helper.stub(:blacklight_config => double(:index => double(:thumbnail_method => :xyz)))
+      allow(helper).to receive_messages(:blacklight_config => double(:index => double(:thumbnail_method => :xyz)))
       document = double()
-      helper.stub(:xyz => "some-thumbnail")
+      allow(helper).to receive_messages(:xyz => "some-thumbnail")
 
-      helper.should_receive(:link_to_document).with(document, :label => "some-thumbnail")
+      expect(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 => double(:index => OpenStruct.new(:thumbnail_field => :xyz)))
+      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_field => :xyz)))
       document = double()
 
-      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"))
+      expect(helper).to receive(:link_to_document).with(document, :label => image_tag("http://example.com/some.jpg"))
       helper.render_thumbnail_tag document
     end
 
     it "should return nil if no thumbnail is available" do
-      helper.stub(:blacklight_config => double(:index => OpenStruct.new()))
+      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new()))
 
       document = double()
       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 => double(:index => OpenStruct.new(:thumbnail_method => :xyz)))
-      helper.stub(:xyz => nil)
+      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_method => :xyz)))
+      allow(helper).to receive_messages(:xyz => nil)
       document = double()
 
       expect(helper.render_thumbnail_tag document).to be_nil
@@ -241,17 +241,17 @@ describe CatalogHelper do
 
   describe "thumbnail_url" do
     it "should pull the configured thumbnail field out of the document" do
-      helper.stub(:blacklight_config => double(:index => double(:thumbnail_field => "xyz")))
+      allow(helper).to receive_messages(:blacklight_config => double(:index => double(: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 => double(:index => double(:thumbnail_field => "xyz")))
+      allow(helper).to receive_messages(:blacklight_config => double(:index => double(: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/facets_helper_spec.rb

@@ -7,9 +7,9 @@ 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
     it "should be true if there are any facets to display" do
 
@@ -18,7 +18,7 @@ describe FacetsHelper do
       empty = double(:items => [])
 
       fields = [a,b,empty]
-      helper.has_facet_values?(fields).should be_true
+      expect(helper.has_facet_values?(fields)).to be_truthy
     end
 
     it "should be false if all facets are empty" do
@@ -26,7 +26,7 @@ describe FacetsHelper do
       empty = double(:items => [])
 
       fields = [empty]
-      helper.has_facet_values?(fields).should_not be_true
+      expect(helper.has_facet_values?(fields)).not_to be_truthy
     end
   end
 
@@ -41,42 +41,42 @@ 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
       a = double(:items => [1,2], :name=>'basic_field')
-      helper.should_render_facet?(a).should == true
+      expect(helper.should_render_facet?(a)).to eq(true)
     end
     it "should not render facets without items" do
       empty = double(:items => [], :name=>'basic_field')
-      helper.should_render_facet?(empty).should ==  false
+      expect(helper.should_render_facet?(empty)).to eq(false)
     end
 
     it "should not render facets where show is set to false" do
       a = double(:items => [1,2], :name=>'no_show')
-      helper.should_render_facet?(a).should ==  false
+      expect(helper.should_render_facet?(a)).to eq(false)
     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
+      expect(helper.should_render_facet?(a)).to eq 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(a).and_return(true)
-      expect(helper.should_render_facet?(a)).to be_true
+      expect(helper).to receive(:my_helper_with_an_arg).with(a).and_return(true)
+      expect(helper.should_render_facet?(a)).to eq true
     end
 
 
     it "should evaluate a Proc to determine if it should render a field" do
       a = double(:items => [1,2], :name=>'lambda_show')
-      expect(helper.should_render_facet?(a)).to be_true
+      expect(helper.should_render_facet?(a)).to eq true
 
       a = double(:items => [1,2], :name=>'lambda_no_show')
-      expect(helper.should_render_facet?(a)).to be_false
+      expect(helper.should_render_facet?(a)).to eq false
     end
   end
 
@@ -84,24 +84,24 @@ 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)
+      expect(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)
+      expect(@response).to receive(:facet_by_field_name).with('a').and_return(facet_field)
 
-      helper.facet_by_field_name('a').should == 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)
+      expect(helper).to receive(:facet_configuration_for_field).with('a_query_facet_field').and_return(facet_config)
+      expect(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
 
     describe "query facets" do
-      let(:facet_config) { 
+      let(:facet_config) {
         double(
           :query => {
              'a_simple_query' => { :fq => 'field:search', :label => 'A Human Readable label'},
@@ -112,7 +112,7 @@ describe FacetsHelper do
       }
 
       before(:each) do
-        helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+        expect(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
         @response = double(:facet_queries => {
           'field:search' => 10,
@@ -124,17 +124,17 @@ 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
 
-        field.name.should == 'my_query_facet_field'
-        field.items.length.should == 2
-        field.items.map { |x| x.value }.should_not include 'field:not_appearing_in_the_config'
+        expect(field.name).to eq('my_query_facet_field')
+        expect(field.items.length).to eq(2)
+        expect(field.items.map { |x| x.value }).not_to include 'field:not_appearing_in_the_config'
 
         facet_item = field.items.select { |x| x.value == 'a_simple_query' }.first
 
-        facet_item.value.should == 'a_simple_query'
-        facet_item.hits.should == 10
-        facet_item.label.should == 'A Human Readable label'
+        expect(facet_item.value).to eq('a_simple_query')
+        expect(facet_item.hits).to eq(10)
+        expect(facet_item.label).to eq('A Human Readable label')
       end
     end
 
@@ -143,24 +143,24 @@ describe FacetsHelper do
         double(:pivot => ['field_a', 'field_b'])
       }
 
-      before(:each) do 
-        helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
-      
+      before(:each) do
+        expect(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
 
-        field.name.should == 'my_pivot_facet_field'
+        expect(field.name).to eq('my_pivot_facet_field')
 
-        field.items.length.should == 1
+        expect(field.items.length).to eq(1)
 
-        field.items.first.should respond_to(:items)
+        expect(field.items.first).to respond_to(:items)
 
-        field.items.first.items.length.should == 1
-        field.items.first.items.first.fq.should == { 'field_a' => 'a' }
+        expect(field.items.first.items.length).to eq(1)
+        expect(field.items.first.items.first.fq).to eq({ 'field_a' => 'a' })
       end
     end
   end
@@ -174,9 +174,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, {})
+      expect(helper).to receive(:render_facet_limit).with(a, {})
+      expect(helper).to receive(:render_facet_limit).with(b, {})
+      expect(helper).to receive(:render_facet_limit).with(empty, {})
 
       helper.render_facet_partials fields
     end
@@ -184,10 +184,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] }
+      expect(helper).to receive(:facet_field_names) { [a,b] }
 
-      helper.should_receive(:render_facet_limit).with(a, {})
-      helper.should_receive(:render_facet_limit).with(b, {})
+      expect(helper).to receive(:render_facet_limit).with(a, {})
+      expect(helper).to receive(:render_facet_limit).with(b, {})
 
       helper.render_facet_partials
     end
@@ -204,15 +204,15 @@ 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', 
-                                                         :locals => { 
-                                                            :solr_field => 'basic_field', 
+      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_limit',
+                                                         :locals => {
+                                                            :solr_field => 'basic_field',
                                                             :solr_fname => 'basic_field',
                                                             :facet_field => helper.blacklight_config.facet_fields['basic_field'],
                                                             :display_facet => @mock_facet  }
@@ -222,39 +222,39 @@ 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'))
+      expect(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'))
+      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
       helper.render_facet_limit(@mock_facet)
-    end 
+    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'))
+      expect(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))
+      expect(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'))
+      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_pivot'))
       helper.render_facet_limit(@mock_facet)
-    end 
+    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'))
+      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
       helper.render_facet_limit(@mock_facet)
-    end 
+    end
 
     it "should be deprecated when a string is passed" do
       expect(@response).to receive(:facet_by_field_name)
@@ -271,84 +271,84 @@ describe FacetsHelper do
     end
 
     it "should add facet value for no pre-existing facets" do
-      helper.stub(:params).and_return(@params_no_existing_facet)
+      allow(helper).to receive(:params).and_return(@params_no_existing_facet)
 
       result_params = helper.add_facet_params("facet_field", "facet_value")
-      result_params[:f].should be_a_kind_of(Hash)
-      result_params[:f]["facet_field"].should be_a_kind_of(Array)
-      result_params[:f]["facet_field"].should == ["facet_value"]
+      expect(result_params[:f]).to be_a_kind_of(Hash)
+      expect(result_params[:f]["facet_field"]).to be_a_kind_of(Array)
+      expect(result_params[:f]["facet_field"]).to eq(["facet_value"])
     end
 
     it "should add a facet param to existing facet constraints" do
-      helper.stub(:params).and_return(@params_existing_facets)
-      
+      allow(helper).to receive(:params).and_return(@params_existing_facets)
+
       result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
 
-      result_params[:f].should be_a_kind_of(Hash)
+      expect(result_params[:f]).to be_a_kind_of(Hash)
 
       @params_existing_facets[:f].each_pair do |facet_field, value_list|
-        result_params[:f][facet_field].should be_a_kind_of(Array)
-        
+        expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
+
         if facet_field == 'facet_field_2'
-          result_params[:f][facet_field].should == (@params_existing_facets[:f][facet_field] | ["new_facet_value"])
+          expect(result_params[:f][facet_field]).to eq(@params_existing_facets[:f][facet_field] | ["new_facet_value"])
         else
-          result_params[:f][facet_field].should ==  @params_existing_facets[:f][facet_field]
-        end        
+          expect(result_params[:f][facet_field]).to eq(@params_existing_facets[:f][facet_field])
+        end
       end
     end
     it "should leave non-facet params alone" do
       [@params_existing_facets, @params_no_existing_facet].each do |params|
-        helper.stub(:params).and_return(params)
+        allow(helper).to receive(:params).and_return(params)
 
         result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
 
         params.each_pair do |key, value|
           next if key == :f
-          result_params[key].should == params[key]
-        end        
+          expect(result_params[key]).to eq(params[key])
+        end
       end
-    end    
+    end
 
     it "should replace facets for facets configured as single" do
-      helper.should_receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(:single => true))
+      expect(helper).to receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(:single => true))
       params = { :f => { 'single_value_facet_field' => 'other_value'}}
-      helper.stub(:params).and_return params
+      allow(helper).to receive(:params).and_return params
 
       result_params = helper.add_facet_params('single_value_facet_field', 'my_value')
 
 
-      result_params[:f]['single_value_facet_field'].length.should == 1
-      result_params[:f]['single_value_facet_field'].first.should == 'my_value'
+      expect(result_params[:f]['single_value_facet_field'].length).to eq(1)
+      expect(result_params[:f]['single_value_facet_field'].first).to eq('my_value')
     end
 
     it "should accept a FacetItem instead of a plain facet value" do
-          
+
       result_params = helper.add_facet_params('facet_field_1', double(:value => 123))
 
-      result_params[:f]['facet_field_1'].should include(123)
+      expect(result_params[:f]['facet_field_1']).to include(123)
     end
 
     it "should defer to the field set on a FacetItem" do
-          
+
       result_params = helper.add_facet_params('facet_field_1', double(:field => 'facet_field_2', :value => 123))
 
-      result_params[:f]['facet_field_1'].should be_blank
-      result_params[:f]['facet_field_2'].should include(123)
+      expect(result_params[:f]['facet_field_1']).to be_blank
+      expect(result_params[:f]['facet_field_2']).to include(123)
     end
 
     it "should add any extra fq parameters from the FacetItem" do
-          
+
       result_params = helper.add_facet_params('facet_field_1', double(:value => 123, :fq => {'facet_field_2' => 'abc'}))
 
-      result_params[:f]['facet_field_1'].should include(123)
-      result_params[:f]['facet_field_2'].should include('abc')
+      expect(result_params[:f]['facet_field_1']).to include(123)
+      expect(result_params[:f]['facet_field_2']).to include('abc')
     end
   end
 
   describe "add_facet_params_and_redirect" do
     before do
-      catalog_facet_params = {:q => "query", 
-                :search_field => "search_field", 
+      catalog_facet_params = {:q => "query",
+                :search_field => "search_field",
                 :per_page => "50",
                 :page => "5",
                 :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
@@ -356,25 +356,25 @@ describe FacetsHelper do
                 Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
                 :id => 'facet_field_name'
       }
-      helper.stub(:params).and_return(catalog_facet_params)
+      allow(helper).to receive(:params).and_return(catalog_facet_params)
     end
     it "should redirect to 'index' action" do
       params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
 
-      params[:action].should == "index"
+      expect(params[:action]).to eq("index")
     end
     it "should not include request parameters used by the facet paginator" do
       params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
 
       bad_keys = Blacklight::Solr::FacetPaginator.request_keys.values + [:id]
       bad_keys.each do |paginator_key|
-        params.keys.should_not include(paginator_key)        
+        expect(params.keys).not_to include(paginator_key)
       end
     end
     it 'should remove :page request key' do
       params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
 
-      params.keys.should_not include(:page)
+      expect(params.keys).not_to include(:page)
     end
     it "should otherwise do the same thing as add_facet_params" do
       added_facet_params = helper.add_facet_params("facet_field_2", "facet_value")
@@ -382,8 +382,8 @@ describe FacetsHelper do
 
       added_facet_params_from_facet_action.each_pair do |key, value|
         next if key == :action
-        value.should == added_facet_params[key]
-      end      
+        expect(value).to eq(added_facet_params[key])
+      end
     end
   end
 
@@ -393,9 +393,9 @@ 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"]}})
-      expect(helper.facet_field_in_params?("some-field")).to be_true
-      expect(helper.facet_field_in_params?("other-field")).to_not be_true
+      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_truthy
     end
   end
 
@@ -405,53 +405,53 @@ describe FacetsHelper do
 
   describe "render_facet_value" do
     it "should use facet_display_value" 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('link')
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false))
+
+      expect(helper).to receive(:facet_display_value).and_return('Z')
+      expect(helper).to receive(:add_facet_params_and_redirect).and_return('link')
       expected  = Nokogiri::HTML "<a class=\"facet_select\" href=\"link\">Z</a> <span class=\"count\">10</span>"
       rendered  = Nokogiri::HTML helper.render_facet_value('simple_field', double(:value => 'A', :hits => 10))
 
-      rendered.should be_equivalent_to(expected).respecting_element_order
+      expect(rendered).to be_equivalent_to(expected).respecting_element_order
     end
 
 
     it "should suppress the link" 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('link')
-      helper.render_facet_value('simple_field', double(:value => 'A', :hits => 10), :suppress_link => true).should == "Z <span class=\"count\">10</span>"
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false))
+
+      expect(helper).to receive(:facet_display_value).and_return('Z')
+      expect(helper).to receive(:add_facet_params_and_redirect).and_return('link')
+      expect(helper.render_facet_value('simple_field', double(:value => 'A', :hits => 10), :suppress_link => true)).to eq("Z <span class=\"count\">10</span>")
     end
   end
- 
+
   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))
-      helper.facet_display_value('simple_field', 'asdf').should == 'asdf'
+      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))
-    
-      helper.should_receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
+      allow(helper).to receive(:facet_configuration_for_field).with('helper_field').and_return(double(:query => nil, :date => nil, :helper_method => :my_facet_value_renderer))
+
+      expect(helper).to receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
 
-      helper.facet_display_value('helper_field', 'qwerty').should == '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))
-      helper.facet_display_value('query_facet', 'query_key').should == 'XYZ'
+      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))
-      helper.facet_display_value('date_facet', '2012-01-01').should == 'Sun, 01 Jan 2012 00:00:00 +0000'
+      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))
-      helper.facet_display_value('date_facet', '2012-01-01').should == '01 Jan 00:00'
+      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
 end