blacklight 6.21.0 → 7.0.0

data/spec/helpers/{configuration_helper_spec.rb → blacklight/configuration_helper_behavior_spec.rb}

@@ -1,36 +1,31 @@
 # frozen_string_literal: true
 
-describe BlacklightConfigurationHelper do
+RSpec.describe Blacklight::ConfigurationHelperBehavior do
   let(:blacklight_config) { Blacklight::Configuration.new }
-  let(:config_value) { double() }
+  let(:config_value) { double }
 
-  before :each do
+  before do
     allow(helper).to receive_messages(blacklight_config: blacklight_config)
   end
 
   describe "#index_fields" do
     it "passes through the configuration" do
+      allow(Deprecation).to receive(:warn)
       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 "converts the sort fields to select-ready values" do
-      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 "restricts the configured sort fields to only those that should be displayed" do
-      allow(blacklight_config).to receive_messages(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 "passes through the configuration" do
+      allow(Deprecation).to receive(:warn)
       allow(blacklight_config).to receive_messages(show_fields: config_value)
       expect(helper.document_show_fields).to eq config_value
     end
@@ -43,13 +38,13 @@ describe BlacklightConfigurationHelper do
       blacklight_config.view.b.default = true
       expect(helper.default_document_index_view_type).to eq :b
     end
-    
+
     it "defaults to the first configured index view" do
-      allow(blacklight_config).to receive_messages(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
-  
+
   describe "#document_index_views" do
     before do
       blacklight_config.view.abc = false
@@ -59,9 +54,9 @@ describe BlacklightConfigurationHelper do
 
     it "filters views using :if/:unless configuration" do
       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
+      expect(helper.document_index_views).not_to have_key :abc
+      expect(helper.document_index_views).not_to have_key :def
+      expect(helper.document_index_views).not_to have_key :xyz
     end
   end
 
@@ -78,9 +73,14 @@ describe BlacklightConfigurationHelper do
   end
 
   describe "#has_alternative_views?" do
-    subject { helper.has_alternative_views?}
+    subject { helper.has_alternative_views? }
+
+    before do
+      blacklight_config.view.clear
+    end
+
     describe "with a single view defined" do
-      it { should be false }
+      it { is_expected.to be false }
     end
 
     describe "with multiple views defined" do
@@ -89,7 +89,7 @@ describe BlacklightConfigurationHelper do
         blacklight_config.view.xyz
       end
 
-      it { should be true }
+      it { is_expected.to be true }
     end
   end
 
@@ -108,7 +108,7 @@ describe BlacklightConfigurationHelper do
       f = helper.document_show_link_field document
       expect(f).to eq :a
     end
-    
+
     it "retrieves the first field with data" do
       blacklight_config.index.title_field = [:zzz, :b]
       f = helper.document_show_link_field document
@@ -122,36 +122,9 @@ describe BlacklightConfigurationHelper do
     end
   end
 
-  describe "#index_field_label" do
-    let(:document) { instance_double(SolrDocument) }
-    it "looks up the label to display for the given document and field" do
-      allow(helper).to receive(:index_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:field_label).with(:"blacklight.search.fields.index.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
-      helper.index_field_label document, "my_field"
-    end
-  end
-
-  describe "#document_show_field_label" do
-    let(:document) { instance_double(SolrDocument) }
-    it "looks up the label to display for the given document and field" do
-      allow(helper).to receive(:document_show_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:field_label).with(:"blacklight.search.fields.show.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
-      helper.document_show_field_label document, "my_field"
-    end
-  end
-
-  describe "#facet_field_label" do
-    let(:document) { instance_double(SolrDocument) }
-    it "looks up the label to display for the given document and field" do
-      allow(blacklight_config).to receive(:facet_fields).and_return({ "my_field" => double(label: "some label") })
-      allow(helper).to receive(:field_label).with(:"blacklight.search.fields.facet.my_field", :"blacklight.search.fields.my_field", "some label", "My field")
-      helper.facet_field_label "my_field"
-    end
-  end
-
   describe "#view_label" do
     it "looks up the label to display for the view" do
-      allow(blacklight_config).to receive(:view).and_return({ "my_view" => double(label: "some label", title: nil) })
+      allow(blacklight_config).to receive(:view).and_return("my_view" => double(label: "some label", title: nil))
       allow(helper).to receive(:field_label).with(:"blacklight.search.view_title.my_view", :"blacklight.search.view.my_view", "some label", nil, "My view")
 
       helper.view_label "my_view"
@@ -160,50 +133,68 @@ describe BlacklightConfigurationHelper do
 
   describe "#field_label" do
     it "looks up the label as an i18n string" do
-      allow(helper).to receive(:t).with(:some_key, default: []).and_return "my label"
+      expect(helper).to receive(:t).with(:some_key, default: []).and_return "my label"
       label = helper.field_label :some_key
 
       expect(label).to eq "my label"
     end
 
     it "passes the provided i18n keys to I18n.t" do
-      allow(helper).to receive(:t).with(:key_a, default: [:key_b, "default text"])
+      expect(helper).to receive(:t).with(:key_a, default: [:key_b, "default text"])
 
-      label = helper.field_label :key_a, :key_b, "default text"
+      helper.field_label :key_a, :key_b, "default text"
     end
 
     it "compacts nil keys (fixes rails/rails#19419)" do
-      allow(helper).to receive(:t).with(:key_a, default: [:key_b])
-
-      label = helper.field_label :key_a, nil, :key_b
+      expect(helper).to receive(:t).with(:key_a, default: [:key_b])
 
+      helper.field_label :key_a, nil, :key_b
     end
   end
-  
+
   describe "#default_per_page" do
-    it "is the configured default per page" do
-      allow(helper).to receive_messages(blacklight_config: double(default_per_page: 42))
-      expect(helper.default_per_page).to eq 42
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
+    context "when default_per_page is configured" do
+      before do
+        blacklight_config.default_per_page = 42
+      end
+
+      it "is the configured value" do
+        expect(helper.default_per_page).to eq 42
+      end
     end
-    
-    it "is the first per-page value if a default isn't set" do
-      allow(helper).to receive_messages(blacklight_config: double(default_per_page: nil, per_page: [11, 22]))
-      expect(helper.default_per_page).to eq 11
+
+    context "when default_per_page is not configured" do
+      before do
+        blacklight_config.per_page = [11, 22]
+      end
+
+      it "is the first per-page value if a default isn't set" do
+        expect(helper.default_per_page).to eq 11
+      end
     end
   end
-  
+
   describe "#default_sort_field" do
     it "is the configured default field" do
       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 "is the first per-page value if a default isn't set" do
+
+    it "is the first active sort field value if a default isn't set" do
       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
+
+    it "is the first active sort field value if the configured default field is not active" do
+      allow(helper).to receive_messages(blacklight_config: double(sort_fields: { a: double(default: nil, key: 'a'), b: double(key: 'b', default: true, if: false) }))
+      expect(helper.default_sort_field.key).to eq 'a'
+    end
   end
-  
+
   describe "#per_page_options_for_select" do
     it "is the per-page values formatted as options_for_select" do
       allow(helper).to receive_messages(blacklight_config: double(per_page: [11, 22, 33]))
@@ -212,23 +203,24 @@ describe BlacklightConfigurationHelper do
       expect(helper.per_page_options_for_select).to include ["33<span class=\"sr-only\"> per page</span>", 33]
     end
   end
-  
+
   describe "#should_render_field?" do
     let(:field_config) { double('field config', if: true, unless: false) }
-    
+
     before do
+      allow(Deprecation).to receive(:warn)
       allow(helper).to receive_messages(document_has_value?: true)
     end
 
     it "is true" do
       expect(helper.should_render_field?(field_config)).to be true
     end
-    
+
     it "is false if the :if condition is false" do
       allow(field_config).to receive_messages(if: false)
       expect(helper.should_render_field?(field_config)).to be false
     end
-    
+
     it "is false if the :unless condition is true" do
       allow(field_config).to receive_messages(unless: true)
       expect(helper.should_render_field?(field_config)).to be false
@@ -236,32 +228,29 @@ describe BlacklightConfigurationHelper do
   end
 
   describe "#search_field_options_for_select" do
-    
     before do
-    
       @config = Blacklight::Configuration.new do |config|
-        config.default_solr_params = { :qt => 'search' }
-        
-        config.add_search_field 'all_fields', :label => 'All Fields'
-        config.add_search_field 'title', :qt => 'title_search'
-        config.add_search_field 'author', :qt => 'author_search'
-        config.add_search_field 'subject', :qt => 'subject_search'
-        config.add_search_field 'no_display', :qt => 'something', :include_in_simple_select => false
+        config.default_solr_params = { qt: 'search' }
+
+        config.add_search_field 'all_fields', label: 'All Fields'
+        config.add_search_field 'title', qt: 'title_search'
+        config.add_search_field 'author', qt: 'author_search'
+        config.add_search_field 'subject', qt: 'subject_search'
+        config.add_search_field 'no_display', qt: 'something', include_in_simple_select: false
       end
 
       allow(helper).to receive_messages(blacklight_config: @config)
     end
-    
-    it "returns proper options_for_select arguments" do
 
+    it "returns proper options_for_select arguments" do
       select_arguments = helper.search_field_options_for_select
 
       select_arguments.each do |(label, key)|
-         config_hash = @config.search_fields[key]
+        config_hash = @config.search_fields[key]
 
-         expect(label).to eq config_hash.label
-         expect(key).to eq config_hash.key
-      end    
+        expect(label).to eq config_hash.label
+        expect(key).to eq config_hash.key
+      end
     end
 
     it "does not include fields in select if :display_in_simple_search=>false" do
@@ -271,17 +260,33 @@ describe BlacklightConfigurationHelper do
     end
   end
 
-  describe "#label_for_search_field" do
+  context 'labels' do
+    let(:field_config) { { 'my-key' => double('field', display_label: 'My Field') } }
+
     before do
-      blacklight_config.add_search_field 'title', :qt => 'title_search'
+      allow(helper).to receive_messages(blacklight_config: config)
     end
 
-    it "finds label by key" do
-      expect(helper.label_for_search_field("title")).to eq "Title"
+    describe '#label_for_search_field' do
+      let(:config) { double('Blacklight configuration', search_fields: field_config) }
+
+      it 'handles a found key' do
+        expect(helper.label_for_search_field('my-key')).to eq 'My Field'
+      end
+      it 'handles a missing key' do
+        expect(helper.label_for_search_field('not-found')).to eq 'Not Found'
+      end
     end
 
-    it "supplies default label for key not found" do
-      expect(helper.label_for_search_field("non_existent_key")).to eq "Non existent key"
+    describe '#sort_field_label' do
+      let(:config) { double('Blacklight configuration', sort_fields: field_config) }
+
+      it 'handles a found key' do
+        expect(helper.sort_field_label('my-key')).to eq 'My Field'
+      end
+      it 'handles a missing key' do
+        expect(helper.sort_field_label('not-found')).to eq 'Not Found'
+      end
     end
   end
 end

data/spec/helpers/{facets_helper_spec.rb → blacklight/facets_helper_behavior_spec.rb}

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-describe FacetsHelper do
+RSpec.describe Blacklight::FacetsHelperBehavior do
   let(:blacklight_config) { Blacklight::Configuration.new }
 
-  before(:each) do
+  before do
     allow(helper).to receive(:blacklight_config).and_return blacklight_config
   end
 
   describe "has_facet_values?" do
-    let(:empty) { double(:items => [], :name => 'empty') }
+    let(:empty) { double(items: [], name: 'empty') }
 
     it "is true if there are any facets to display" do
-      a = double(:items => [1, 2], :name => 'a')
-      b = double(:items => ['b', 'c'], :name => 'b')
+      a = double(items: [1, 2], name: 'a')
+      b = double(items: %w[b c], name: 'b')
       fields = [a, b, empty]
       expect(helper.has_facet_values?(fields)).to be true
     end
@@ -22,9 +22,10 @@ describe FacetsHelper do
     end
 
     describe "different config" do
-      let(:blacklight_config) { Blacklight::Configuration.new { |config| config.add_facet_field 'basic_field', :if => false } }
+      let(:blacklight_config) { Blacklight::Configuration.new { |config| config.add_facet_field 'basic_field', if: false } }
+
       it "is false if no facets are displayable" do
-        a = double(:items => [1, 2], :name => 'basic_field')
+        a = double(items: [1, 2], name: 'basic_field')
         expect(helper.has_facet_values?([a])).to be false
       end
     end
@@ -34,45 +35,45 @@ describe FacetsHelper do
     let(:blacklight_config) do
       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_custom_check
-        config.add_facet_field 'helper_with_an_arg_show', :show => :my_custom_check_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
+        config.add_facet_field 'helper_show', show: :my_custom_check
+        config.add_facet_field 'helper_with_an_arg_show', show: :my_custom_check_with_an_arg
+        config.add_facet_field 'lambda_show',    show: ->(_context, _config, _field) { true }
+        config.add_facet_field 'lambda_no_show', show: ->(_context, _config, _field) { false }
       end
     end
 
     it "renders facets with items" do
-      a = double(:items => [1, 2], :name => 'basic_field')
+      a = double(items: [1, 2], name: 'basic_field')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "does not render facets without items" do
-      empty = double(:items => [], :name => 'basic_field')
+      empty = double(items: [], name: 'basic_field')
       expect(helper.should_render_facet?(empty)).to be false
     end
 
     it "does not render facets where show is set to false" do
-      a = double(:items => [1, 2], :name => 'no_show')
+      a = double(items: [1, 2], name: 'no_show')
       expect(helper.should_render_facet?(a)).to be false
     end
 
     it "calls a helper to determine if it should render a field" do
-      allow(controller).to receive_messages(:my_custom_check => true)
-      a = double(:items => [1, 2], :name => 'helper_show')
+      allow(controller).to receive_messages(my_custom_check: true)
+      a = double(items: [1, 2], name: 'helper_show')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "calls a helper to determine if it should render a field" do
-      a = double(:items => [1, 2], :name => 'helper_with_an_arg_show')
+      a = double(items: [1, 2], name: 'helper_with_an_arg_show')
       allow(controller).to receive(:my_custom_check_with_an_arg).with(blacklight_config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "evaluates a Proc to determine if it should render a field" do
-      a = double(:items => [1, 2], :name => 'lambda_show')
+      a = double(items: [1, 2], name: 'lambda_show')
       expect(helper.should_render_facet?(a)).to be true
-      a = double(:items => [1, 2], :name => 'lambda_no_show')
+      a = double(items: [1, 2], name: 'lambda_no_show')
       expect(helper.should_render_facet?(a)).to be false
     end
   end
@@ -103,7 +104,7 @@ describe FacetsHelper do
   describe "facet_by_field_name" do
     it "retrieves the facet from the response given a string" do
       facet_config = double(query: nil, field: 'b', key: 'a')
-      facet_field = double()
+      facet_field = double
       allow(helper).to receive(:facet_configuration_for_field).with('b').and_return(facet_config)
       @response = instance_double(Blacklight::Solr::Response, aggregations: { 'b' => facet_field })
 
@@ -112,11 +113,11 @@ describe FacetsHelper do
   end
 
   describe "render_facet_partials" do
-    let(:a) { double(:items => [1, 2]) }
-    let(:b) { double(:items => ['b', 'c']) }
+    let(:a) { double(items: [1, 2]) }
+    let(:b) { double(items: %w[b c]) }
 
     it "tries to render all provided facets" do
-      empty = double(:items => [])
+      empty = double(items: [])
       fields = [a, b, empty]
       expect(helper).to receive(:render_facet_limit).with(a, {})
       expect(helper).to receive(:render_facet_limit).with(b, {})
@@ -136,64 +137,65 @@ describe FacetsHelper do
     let(:blacklight_config) do
       Blacklight::Configuration.new do |config|
         config.add_facet_field 'basic_field'
-        config.add_facet_field 'pivot_facet_field', :pivot => ['a', 'b']
-        config.add_facet_field 'my_pivot_facet_field_with_custom_partial', :partial => 'custom_facet_partial', :pivot => ['a', 'b']
-        config.add_facet_field 'my_facet_field_with_custom_partial', :partial => 'custom_facet_partial'
+        config.add_facet_field 'pivot_facet_field', pivot: %w[a b]
+        config.add_facet_field 'my_pivot_facet_field_with_custom_partial', partial: 'custom_facet_partial', pivot: %w[a b]
+        config.add_facet_field 'my_facet_field_with_custom_partial', partial: 'custom_facet_partial'
       end
     end
-    let(:mock_custom_facet) { double(:name => 'my_facet_field_with_custom_partial', :items => [1, 2, 3]) }
+    let(:mock_custom_facet) { double(name: 'my_facet_field_with_custom_partial', items: [1, 2, 3]) }
 
     it "sets 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 => {
-                                                                :solr_field => 'basic_field',
-                                                                :field_name => 'basic_field',
-                                                                :facet_field => helper.blacklight_config.facet_fields['basic_field'],
-                                                                :display_facet => mock_facet  }
-                                                            ))
+      mock_facet = double(name: 'basic_field', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit',
+                                                             locals: {
+                                                               field_name: 'basic_field',
+                                                               facet_field: helper.blacklight_config.facet_fields['basic_field'],
+                                                               display_facet: mock_facet
+                                                             }))
       helper.render_facet_limit(mock_facet)
     end
 
     it "renders 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'))
+      mock_facet = double(name: 'asdf', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit'))
       helper.render_facet_limit(mock_facet)
     end
 
     it "gets the partial name from the configuration" do
-      expect(helper).to 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_custom_facet)
     end
 
     it "uses a partial layout for rendering the facet frame" do
-      expect(helper).to receive(:render).with(hash_including(:layout => 'facet_layout'))
+      expect(helper).to receive(:render).with(hash_including(layout: 'facet_layout'))
       helper.render_facet_limit(mock_custom_facet)
     end
 
     it "allows the caller to opt-out of facet layouts" do
-      expect(helper).to receive(:render).with(hash_including(:layout => nil))
-      helper.render_facet_limit(mock_custom_facet, :layout => nil)
+      expect(helper).to receive(:render).with(hash_including(layout: nil))
+      helper.render_facet_limit(mock_custom_facet, layout: nil)
     end
 
     it "renders 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'))
+      mock_facet = double(name: 'pivot_facet_field', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_pivot'))
       helper.render_facet_limit(mock_facet)
     end
 
     it "lets 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'))
+      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.render_facet_limit(mock_facet)
     end
   end
 
   describe "render_facet_limit_list" do
+    subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
+
     let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
     let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
     let(:paginator) { Blacklight::Solr::FacetPaginator.new([f1, f2], limit: 10) }
-    subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
+
     before do
       allow(helper).to receive(:search_action_path) do |*args|
         search_catalog_path *args
@@ -202,38 +204,38 @@ describe FacetsHelper do
 
     it "draws a list of elements" do
       expect(subject).to have_selector 'li', count: 2
-      expect(subject).to have_selector 'li:first-child a.facet_select', text: 'Book'
-      expect(subject).to have_selector 'li:nth-child(2) a.facet_select', text: 'Musical Score'
+      expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
+      expect(subject).to have_selector 'li:nth-child(2) a.facet-select', text: 'Musical Score'
     end
 
     context "when one of the facet items is rendered as nil" do
       # An app may override render_facet_item to filter out some undesired facet items by returning nil.
-      before { allow(helper).to receive(:render_facet_item).and_return('<a class="facet_select">Book</a>'.html_safe, nil) }
+      before { allow(helper).to receive(:render_facet_item).and_return('<a class="facet-select">Book</a>'.html_safe, nil) }
 
       it "draws a list of elements" do
         expect(subject).to have_selector 'li', count: 1
-        expect(subject).to have_selector 'li:first-child a.facet_select', text: 'Book'
+        expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
       end
     end
   end
 
   describe "facet_field_in_params?" do
     it "checks 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 true
+      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] } })
+      expect(helper).to be_facet_field_in_params("some-field")
+      expect(helper.facet_field_in_params?("other-field")).not_to be true
     end
   end
 
   describe "facet_params" do
     it "extracts the facet parameters for a field" do
-      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] }})
+      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] } })
       expect(helper.facet_params("some-field")).to match_array ["x"]
     end
 
     it "uses the blacklight key to extract the right fields" do
       blacklight_config.add_facet_field "some-key", field: "some-field"
-      allow(helper).to receive_messages(params: { f: { "some-key" => ["x"] }})
+      allow(helper).to receive_messages(params: { f: { "some-key" => ["x"] } })
       expect(helper.facet_params("some-key")).to match_array ["x"]
       expect(helper.facet_params("some-field")).to match_array ["x"]
     end
@@ -265,10 +267,11 @@ describe FacetsHelper do
   end
 
   describe "render_facet_value" do
-    let(:item) { double(:value => 'A', :hits => 10) }
+    let(:item) { double(value: 'A', hits: 10) }
     let(:search_state) { double(add_facet_params_and_redirect: { controller: 'catalog' }) }
+
     before do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, single: false, url_method: nil))
       allow(helper).to receive(:facet_display_value).and_return('Z')
       allow(helper).to receive(:search_state).and_return(search_state)
       allow(helper).to receive(:search_action_path) do |*args|
@@ -277,7 +280,7 @@ describe FacetsHelper do
     end
 
     describe "simple case" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet_select" href="/catalog">Z</a></span><span class="facet-count">10</span>' }
+      let(:expected_html) { '<span class="facet-label"><a class="facet-select" href="/catalog">Z</a></span><span class="facet-count">10</span>' }
 
       it "uses facet_display_value" do
         result = helper.render_facet_value('simple_field', item)
@@ -286,9 +289,10 @@ describe FacetsHelper do
     end
 
     describe "when :url_method is set" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet_select" href="/blabla">Z</a></span><span class="facet-count">10</span>' }
+      let(:expected_html) { '<span class="facet-label"><a class="facet-select" href="/blabla">Z</a></span><span class="facet-count">10</span>' }
+
       it "uses that method" do
-        allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false, :url_method => :test_method))
+        allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, single: false, url_method: :test_method))
         allow(helper).to receive(:test_method).with('simple_field', item).and_return('/blabla')
         result = helper.render_facet_value('simple_field', item)
         expect(result).to be_equivalent_to(expected_html).respecting_element_order
@@ -297,8 +301,9 @@ describe FacetsHelper do
 
     describe "when :suppress_link is set" do
       let(:expected_html) { '<span class="facet-label">Z</span><span class="facet-count">10</span>' }
+
       it "suppresses the link" do
-        result = helper.render_facet_value('simple_field', item, :suppress_link => true)
+        result = helper.render_facet_value('simple_field', item, suppress_link: true)
         expect(result).to be_equivalent_to(expected_html).respecting_element_order
       end
     end
@@ -306,18 +311,18 @@ describe FacetsHelper do
 
   describe "#facet_display_value" do
     it "justs 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, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, url_method: nil))
       expect(helper.facet_display_value('simple_field', 'asdf')).to eq 'asdf'
     end
 
     it "allows 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, :url_method => 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, url_method: nil, helper_method: :my_facet_value_renderer))
       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 "extracts 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, :url_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, url_method: nil))
       expect(helper.facet_display_value('query_facet', 'query_key')).to eq 'XYZ'
     end
 
@@ -327,14 +332,14 @@ describe FacetsHelper do
     end
 
     it "localizes 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, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { format: :short }, :query => nil, :helper_method => nil, :url_method => nil))
       expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq '01 Jan 00:00'
     end
   end
 
   describe "#facet_field_id" do
     it "is the parameterized version of the facet field" do
-      expect(helper.facet_field_id double(key: 'some field')).to eq "facet-some-field"
+      expect(helper.facet_field_id(double(key: 'some field'))).to eq "facet-some-field"
     end
   end
 end