blacklight 4.9.0 → 5.0.0.pre1

data/spec/helpers/catalog_helper_spec.rb

@@ -11,44 +11,18 @@ 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)
 
-    allow(mock_response).to receive(:docs).and_return(mock_docs.slice(start, per_page))
+    mock_response.stub(:docs).and_return(mock_docs.slice(start, per_page))
     mock_response
   end
 
   def render_grouped_response?
     false
   end
-
-  describe "deprecated methods" do
-    describe "response_has_no_search_results?" 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 eq false
-      end
-    end
-
-    describe "paginate_params" do
-      let(:response) { double }
-      it "should be deprecated" do
-        expect(Blacklight::CatalogHelperBehavior.deprecation_behavior.first).to receive(:call)
-        assign(:response, response)
-        expect(helper.paginate_params(response)).to eq response
-      end
-    end
-
-    describe "format_num" do
-      it "should be deprecated" do
-        expect(Blacklight::CatalogHelperBehavior.deprecation_behavior.first).to receive(:call)
-        expect(format_num(10000)).to eq '10,000'
-      end
-    end
-
-  end
-
+  
+  
   describe "page_entries_info" do
     before(:all) do
     end
@@ -57,16 +31,16 @@ describe CatalogHelper do
       @response = mock_response :total => 0
 
       html = page_entries_info(@response, { :entry_name => 'entry_name' })
-      expect(html).to eq("No entry_names found")
-      expect(html.html_safe?).to eq(true)
+      html.should == "No entry_names found"
+      html.html_safe?.should == true
     end
 
     it "with no results (and no entry_name provided)" do
       @response = mock_response :total => 0
 
       html = page_entries_info(@response)
-      expect(html).to eq("No entries found")
-      expect(html.html_safe?).to eq(true)
+      html.should == "No entries found"
+      html.html_safe?.should == true
     end
 
     describe "with a single result" do
@@ -74,21 +48,21 @@ describe CatalogHelper do
         response = mock_response :total => 1
 
         html = page_entries_info(response, { :entry_name => 'entry_name' })
-        expect(html).to eq("<strong>1</strong> entry_name found")
-        expect(html.html_safe?).to eq(true)
+        html.should == "<strong>1</strong> entry_name found"
+        html.html_safe?.should == true
       end
 
       it "should infer a name" do
         response = mock_response :total => 1
 
         html = page_entries_info(response)
-        expect(html).to eq("<strong>1</strong> entry found")
-        expect(html.html_safe?).to eq(true)
+        html.should == "<strong>1</strong> entry found"
+        html.html_safe?.should == true
       end
 
       it "should use the model_name from the response" do
         response = mock_response :total => 1
-        allow(response).to receive(:model_name).and_return(double(:human => 'thingy'))
+        response.stub(:model_name).and_return('thingy')
 
         html = page_entries_info(response)
         expect(html).to eq "<strong>1</strong> thingy found"
@@ -100,139 +74,126 @@ describe CatalogHelper do
       response = mock_response :total => 7
 
       html = page_entries_info(response, { :entry_name => 'entry_name' })
-      expect(html).to eq("<strong>1</strong> - <strong>7</strong> of <strong>7</strong>")
-      expect(html.html_safe?).to eq(true)
+      html.should == "<strong>1</strong> - <strong>7</strong> of <strong>7</strong>"
+      html.html_safe?.should == 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' })
-      expect(html).to eq("<strong>1</strong> - <strong>10</strong> of <strong>15</strong>")
-      expect(html.html_safe?).to eq(true)
+      html.should == "<strong>1</strong> - <strong>10</strong> of <strong>15</strong>"
+      html.html_safe?.should == 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' })
-      expect(html).to eq("<strong>11</strong> - <strong>20</strong> of <strong>47</strong>")
-      expect(html.html_safe?).to eq(true)
+      html.should == "<strong>11</strong> - <strong>20</strong> of <strong>47</strong>"
+      html.html_safe?.should == 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' })
-      expect(html).to eq("<strong>41</strong> - <strong>47</strong> of <strong>47</strong>")
-      expect(html.html_safe?).to eq(true)
+      html.should == "<strong>41</strong> - <strong>47</strong> of <strong>47</strong>"
+      html.html_safe?.should == 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' })
-      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' })
-
-      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
-      50.times { b = Bookmark.new;  b.user_id = 1; b.save! }
-      html = helper.page_entries_info(Bookmark.page(1).per(25))
-      expect(html).to eq "<strong>1</strong> - <strong>25</strong> of <strong>50</strong>"
+      html.should == "<strong>21</strong> - <strong>40</strong> of <strong>47</strong>"
+      html.html_safe?.should == true
     end
 
   end
 
   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
-      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "index", :params => { })
-      expect(helper.should_autofocus_on_search_box?).to eq true
+      helper.stub(:controller => CatalogController.new, :action_name => "index", :params => { })
+      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
-      allow(helper).to receive_messages(:controller => ApplicationController.new)
-      expect(helper.should_autofocus_on_search_box?).to eq false
+      helper.stub(: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
-      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "show")
-      expect(helper.should_autofocus_on_search_box?).to eq false
+      helper.stub(: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 string is provided" do
-      allow(helper).to receive_messages(:controller => CatalogController.new, :action_name => "index", :params => { :q => "hello"})
-      expect(helper.should_autofocus_on_search_box?).to eq false
+      helper.stub(:controller => CatalogController.new, :action_name => "index", :params => { :q => "hello"})
+      expect(helper.should_autofocus_on_search_box?).to be_false
     end
 
     it "should not be focused if a facet is selected" do
-      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
+      helper.stub(:controller => CatalogController.new, :action_name => "index", :params => { :f => { "field" => ["value"]}})
+      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
-      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_method => :xyz) ))
+      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_method => :xyz) ))
       document = double()
-      expect(helper.has_thumbnail? document).to be_truthy
+      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
-      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
+      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
       document = double(:has? => true)
-      expect(helper.has_thumbnail? document).to be_truthy
+      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
-      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
+      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new(:thumbnail_field => :xyz) ))
       document = double(:has? => false)
-      expect(helper.has_thumbnail? document).to eq false
+      expect(helper.has_thumbnail? document).to be_false
     end
 
     it "should not have a thumbnail if none of the fields are configured" do
-      allow(helper).to receive_messages(:blacklight_config => OpenStruct.new(:index => OpenStruct.new()))
-      expect(helper.has_thumbnail? double()).to be_falsey
+      helper.stub(:blacklight_config => OpenStruct.new(:index => OpenStruct.new()))
+      expect(helper.has_thumbnail? double()).to be_false
     end
   end
 
   describe "render_thumbnail_tag" do
     it "should call the provided thumbnail method" do
-      allow(helper).to receive_messages(:blacklight_config => double(:index => double(:thumbnail_method => :xyz)))
+      helper.stub(:blacklight_config => double(:index => double(:thumbnail_method => :xyz)))
       document = double()
-      allow(helper).to receive_messages(:xyz => "some-thumbnail")
+      helper.stub(:xyz => "some-thumbnail")
 
-      expect(helper).to receive(:link_to_document).with(document, :label => "some-thumbnail")
+      helper.should_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
-      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_field => :xyz)))
+      helper.stub(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_field => :xyz)))
       document = double()
 
-      allow(document).to receive(:has?).with(:xyz).and_return(true)
-      allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
+      document.stub(:has?).with(:xyz).and_return(true)
+      document.stub(:first).with(:xyz).and_return("http://example.com/some.jpg")
 
-      expect(helper).to receive(:link_to_document).with(document, :label => image_tag("http://example.com/some.jpg"))
+      helper.should_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
-      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new()))
+      helper.stub(: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
-      allow(helper).to receive_messages(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_method => :xyz)))
-      allow(helper).to receive_messages(:xyz => nil)
+      helper.stub(:blacklight_config => double(:index => OpenStruct.new(:thumbnail_method => :xyz)))
+      helper.stub(:xyz => nil)
       document = double()
 
       expect(helper.render_thumbnail_tag document).to be_nil
@@ -241,17 +202,17 @@ describe CatalogHelper do
 
   describe "thumbnail_url" do
     it "should pull the configured thumbnail field out of the document" do
-      allow(helper).to receive_messages(:blacklight_config => double(:index => double(:thumbnail_field => "xyz")))
+      helper.stub(:blacklight_config => double(:index => double(:thumbnail_field => "xyz")))
       document = double()
-      allow(document).to receive(:has?).with("xyz").and_return(true)
-      allow(document).to receive(:first).with("xyz").and_return("asdf")
+      document.stub(:has?).with("xyz").and_return(true)
+      document.stub(: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
-      allow(helper).to receive_messages(:blacklight_config => double(:index => double(:thumbnail_field => "xyz")))
+      helper.stub(:blacklight_config => double(:index => double(:thumbnail_field => "xyz")))
       document = double()
-      allow(document).to receive(:has?).with("xyz").and_return(false)
+      document.stub(:has?).with("xyz").and_return(false)
       expect(helper.thumbnail_url document).to be_nil
     end
   end

data/spec/helpers/facets_helper_spec.rb

@@ -1,15 +1,14 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
-require 'nokogiri'
 require 'equivalent-xml'
 
 describe FacetsHelper do
   let(:blacklight_config) { Blacklight::Configuration.new }
 
   before(:each) do
-    allow(helper).to receive(:blacklight_config).and_return blacklight_config
+    helper.stub(: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 +17,7 @@ describe FacetsHelper do
       empty = double(:items => [])
 
       fields = [a,b,empty]
-      expect(helper.has_facet_values?(fields)).to be_truthy
+      helper.has_facet_values?(fields).should be_true
     end
 
     it "should be false if all facets are empty" do
@@ -26,7 +25,7 @@ describe FacetsHelper do
       empty = double(:items => [])
 
       fields = [empty]
-      expect(helper.has_facet_values?(fields)).not_to be_truthy
+      helper.has_facet_values?(fields).should_not be_true
     end
   end
 
@@ -34,49 +33,23 @@ describe FacetsHelper do
     before do
       @config = Blacklight::Configuration.new do |config|
         config.add_facet_field 'basic_field'
-        config.add_facet_field 'no_show', :show => false
-        config.add_facet_field 'helper_show', :show => :my_helper
-        config.add_facet_field 'helper_with_an_arg_show', :show => :my_helper_with_an_arg
-        config.add_facet_field 'lambda_show', :show => lambda { |context, config, field| true }
-        config.add_facet_field 'lambda_no_show', :show => lambda { |context, config, field| false }
+        config.add_facet_field 'no_show', :show=>false
       end
 
-      allow(helper).to receive_messages(:blacklight_config => @config)
+      helper.stub(:blacklight_config => @config)
     end
-
     it "should render facets with items" do
       a = double(:items => [1,2], :name=>'basic_field')
-      expect(helper.should_render_facet?(a)).to eq(true)
+      helper.should_render_facet?(a).should == true
     end
     it "should not render facets without items" do
       empty = double(:items => [], :name=>'basic_field')
-      expect(helper.should_render_facet?(empty)).to eq(false)
+      helper.should_render_facet?(empty).should ==  false
     end
 
     it "should not render facets where show is set to false" do
       a = double(:items => [1,2], :name=>'no_show')
-      expect(helper.should_render_facet?(a)).to eq(false)
-    end
-
-    it "should call a helper to determine if it should render a field" do
-      allow(helper).to receive_messages(:my_helper => true)
-      a = double(:items => [1,2], :name=>'helper_show')
-      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')
-      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 eq true
-
-      a = double(:items => [1,2], :name=>'lambda_no_show')
-      expect(helper.should_render_facet?(a)).to eq false
+      helper.should_render_facet?(a).should ==  false
     end
   end
 
@@ -84,24 +57,24 @@ describe FacetsHelper do
     it "should retrieve the facet from the response given a string" do
       facet_config = double(:query => nil)
       facet_field = double()
-      expect(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+      helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
       @response = double()
-      expect(@response).to receive(:facet_by_field_name).with('a').and_return(facet_field)
+      @response.should_receive(:facet_by_field_name).with('a').and_return(facet_field)
 
-      expect(helper.facet_by_field_name('a')).to eq(facet_field)
+      helper.facet_by_field_name('a').should == facet_field
     end
 
     it "should also work for facet query fields" do
       facet_config = double(:query => {})
-      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.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)
 
       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 +85,7 @@ describe FacetsHelper do
       }
 
       before(:each) do
-        expect(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
+        helper.should_receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
         @response = double(:facet_queries => {
           'field:search' => 10,
@@ -124,17 +97,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')
-        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+        field.should be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
 
-        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'
+        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'
 
         facet_item = field.items.select { |x| x.value == 'a_simple_query' }.first
 
-        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')
+        facet_item.value.should == 'a_simple_query'
+        facet_item.hits.should == 10
+        facet_item.label.should == 'A Human Readable label'
       end
     end
 
@@ -143,24 +116,24 @@ describe FacetsHelper do
         double(:pivot => ['field_a', 'field_b'])
       }
 
-      before(:each) do
-        expect(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
-
+      before(:each) do 
+        helper.should_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')
-        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+        field.should be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
 
-        expect(field.name).to eq('my_pivot_facet_field')
+        field.name.should == 'my_pivot_facet_field'
 
-        expect(field.items.length).to eq(1)
+        field.items.length.should == 1
 
-        expect(field.items.first).to respond_to(:items)
+        field.items.first.should respond_to(:items)
 
-        expect(field.items.first.items.length).to eq(1)
-        expect(field.items.first.items.first.fq).to eq({ 'field_a' => 'a' })
+        field.items.first.items.length.should == 1
+        field.items.first.items.first.fq.should == { 'field_a' => 'a' }
       end
     end
   end
@@ -174,9 +147,9 @@ describe FacetsHelper do
 
       fields = [a,b,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.should_receive(:render_facet_limit).with(a, {})
+      helper.should_receive(:render_facet_limit).with(b, {})
+      helper.should_receive(:render_facet_limit).with(empty, {})
 
       helper.render_facet_partials fields
     end
@@ -184,10 +157,10 @@ describe FacetsHelper do
     it "should default to the configured facets" do
       a = double(:items => [1,2])
       b = double(:items => ['b','c'])
-      expect(helper).to receive(:facet_field_names) { [a,b] }
+      helper.should_receive(:facet_field_names) { [a,b] }
 
-      expect(helper).to receive(:render_facet_limit).with(a, {})
-      expect(helper).to receive(:render_facet_limit).with(b, {})
+      helper.should_receive(:render_facet_limit).with(a, {})
+      helper.should_receive(:render_facet_limit).with(b, {})
 
       helper.render_facet_partials
     end
@@ -204,16 +177,15 @@ describe FacetsHelper do
         config.add_facet_field 'my_facet_field_with_custom_partial', :partial => 'custom_facet_partial'
       end
 
-      allow(helper).to receive_messages(:blacklight_config => @config)
+      helper.stub(:blacklight_config => @config)
       @response = double()
     end
 
     it "should set basic local variables" do
       @mock_facet = double(:name => 'basic_field', :items => [1,2,3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_limit',
-                                                         :locals => {
+      helper.should_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,46 +194,39 @@ describe FacetsHelper do
 
     it "should render a facet _not_ declared in the configuration" do
       @mock_facet = double(:name => 'asdf', :items => [1,2,3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_limit'))
+      helper.should_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])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      helper.should_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])
-      expect(helper).to receive(:render).with(hash_including(:layout => 'facet_layout'))
+      helper.should_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])
-      expect(helper).to receive(:render).with(hash_including(:layout => nil))
+      helper.should_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])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_pivot'))
+      helper.should_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])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      helper.should_receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
       helper.render_facet_limit(@mock_facet)
-    end
-
-    it "should be deprecated when a string is passed" do
-      expect(@response).to receive(:facet_by_field_name)
-      expect(Blacklight::FacetsHelperBehavior.deprecation_behavior.first).to receive(:call)
-      helper.render_facet_limit('basic_field')
-    end
-
+    end 
   end
 
   describe "add_facet_params" do
@@ -271,84 +236,84 @@ describe FacetsHelper do
     end
 
     it "should add facet value for no pre-existing facets" do
-      allow(helper).to receive(:params).and_return(@params_no_existing_facet)
+      helper.stub(:params).and_return(@params_no_existing_facet)
 
       result_params = helper.add_facet_params("facet_field", "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"])
+      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"]
     end
 
     it "should add a facet param to existing facet constraints" do
-      allow(helper).to receive(:params).and_return(@params_existing_facets)
-
+      helper.stub(:params).and_return(@params_existing_facets)
+      
       result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
 
-      expect(result_params[:f]).to be_a_kind_of(Hash)
+      result_params[:f].should be_a_kind_of(Hash)
 
       @params_existing_facets[:f].each_pair do |facet_field, value_list|
-        expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
-
+        result_params[:f][facet_field].should be_a_kind_of(Array)
+        
         if facet_field == 'facet_field_2'
-          expect(result_params[:f][facet_field]).to eq(@params_existing_facets[:f][facet_field] | ["new_facet_value"])
+          result_params[:f][facet_field].should == (@params_existing_facets[:f][facet_field] | ["new_facet_value"])
         else
-          expect(result_params[:f][facet_field]).to eq(@params_existing_facets[:f][facet_field])
-        end
+          result_params[:f][facet_field].should ==  @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|
-        allow(helper).to receive(:params).and_return(params)
+        helper.stub(: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
-          expect(result_params[key]).to eq(params[key])
-        end
+          result_params[key].should == params[key]
+        end        
       end
-    end
+    end    
 
     it "should replace facets for facets configured as single" do
-      expect(helper).to receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(:single => true))
+      helper.should_receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(:single => true))
       params = { :f => { 'single_value_facet_field' => 'other_value'}}
-      allow(helper).to receive(:params).and_return params
+      helper.stub(:params).and_return params
 
       result_params = helper.add_facet_params('single_value_facet_field', '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')
+      result_params[:f]['single_value_facet_field'].length.should == 1
+      result_params[:f]['single_value_facet_field'].first.should == '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))
 
-      expect(result_params[:f]['facet_field_1']).to include(123)
+      result_params[:f]['facet_field_1'].should 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))
 
-      expect(result_params[:f]['facet_field_1']).to be_blank
-      expect(result_params[:f]['facet_field_2']).to include(123)
+      result_params[:f]['facet_field_1'].should be_blank
+      result_params[:f]['facet_field_2'].should 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'}))
 
-      expect(result_params[:f]['facet_field_1']).to include(123)
-      expect(result_params[:f]['facet_field_2']).to include('abc')
+      result_params[:f]['facet_field_1'].should include(123)
+      result_params[:f]['facet_field_2'].should 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 +321,25 @@ describe FacetsHelper do
                 Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
                 :id => 'facet_field_name'
       }
-      allow(helper).to receive(:params).and_return(catalog_facet_params)
+      helper.stub(: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")
 
-      expect(params[:action]).to eq("index")
+      params[:action].should == "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|
-        expect(params.keys).not_to include(paginator_key)
+        params.keys.should_not include(paginator_key)        
       end
     end
     it 'should remove :page request key' do
       params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
 
-      expect(params.keys).not_to include(:page)
+      params.keys.should_not 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 +347,8 @@ describe FacetsHelper do
 
       added_facet_params_from_facet_action.each_pair do |key, value|
         next if key == :action
-        expect(value).to eq(added_facet_params[key])
-      end
+        value.should == added_facet_params[key]
+      end      
     end
   end
 
@@ -393,9 +358,9 @@ describe FacetsHelper do
 
   describe "facet_field_in_params?" do
     it "should check if the facet field is selected in the user params" do
-      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
+      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
     end
   end
 
@@ -404,54 +369,67 @@ describe FacetsHelper do
   end
 
   describe "render_facet_value" do
-    it "should use facet_display_value" do
-      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))
-
-      expect(rendered).to be_equivalent_to(expected).respecting_element_order
+    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'})
+    end
+    describe "simple case" do
+      let(:expected_html) { "<span class=\"facet-label\"><a class=\"facet_select\" href=\"/\">Z</a></span><span class=\"facet-count\">10</span>" }
+      it "should use facet_display_value" do
+        result = helper.render_facet_value('simple_field', item)
+        expect(result).to be_equivalent_to(expected_html).respecting_element_order
+      end
     end
 
+    describe "when :suppress_link is set" do
+      let(:expected_html) { "<span class=\"facet-label\">Z</span><span class=\"facet-count\">10</span>" }
+      it "should suppress the link" do
+        result = helper.render_facet_value('simple_field', item, :suppress_link => true)
+        expect(result).to be_equivalent_to(expected_html).respecting_element_order
+      end
+    end
 
-    it "should suppress the link" do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false))
+    describe "when a route_set is passed" do
+      let(:my_engine) { double("Engine") }
+      let(:expected_html) { "<span class=\"facet-label\"><a class=\"facet_select\" href=\"/\">Z</a></span><span class=\"facet-count\">10</span>" }
 
-      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>")
+      it "should use the engine scope" do
+        expect(my_engine).to receive(:url_for).and_return({controller: 'catalog'})
+        result = helper.render_facet_value('simple_field', item, route_set: my_engine)
+        expect(result).to be_equivalent_to(expected_html).respecting_element_order
+      end
     end
   end
-
+ 
   describe "#facet_display_value" do
     it "should just be the facet value for an ordinary facet" do
-      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')
+      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'
     end
 
     it "should allow you to pass in a :helper_method argument to the configuration" do
-      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.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')
 
-      expect(helper.facet_display_value('helper_field', 'qwerty')).to eq('abc')
+      helper.facet_display_value('helper_field', 'qwerty').should == 'abc'
     end
 
     it "should extract the configuration label for a query facet" do
-      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')
+      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'
     end
 
     it "should localize the label for date-type facets" do
-      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')
+      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'
     end
 
     it "should localize the label for date-type facets with the supplied localization options" do
-      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')
+      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'
     end
   end
 end