blacklight 6.14.0 → 7.0.0

data/spec/helpers/catalog_helper_spec.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-describe CatalogHelper do
+RSpec.describe CatalogHelper do
   include ERB::Util
-  include CatalogHelper
+  include described_class
 
   def mock_response args
     current_page = args[:current_page] || 1
@@ -22,18 +22,17 @@ describe CatalogHelper do
     false
   end
 
-
   describe "page_entries_info" do
     it "with no results" do
-      @response = mock_response :total => 0
+      @response = mock_response total: 0
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      html = page_entries_info(@response, entry_name: 'entry_name')
       expect(html).to eq "No entry_names found"
       expect(html).to be_html_safe
     end
 
     it "with no results (and no entry_name provided)" do
-      @response = mock_response :total => 0
+      @response = mock_response total: 0
 
       html = page_entries_info(@response)
       expect(html).to eq "No entries found"
@@ -49,15 +48,15 @@ describe CatalogHelper do
 
     describe "with a single result" do
       it "uses the provided entry name" do
-        response = mock_response :total => 1
+        response = mock_response total: 1
 
-        html = page_entries_info(response, { :entry_name => 'entry_name' })
+        html = page_entries_info(response, entry_name: 'entry_name')
         expect(html).to eq "<strong>1</strong> entry_name found"
         expect(html).to be_html_safe
       end
 
       it "infers a name" do
-        response = mock_response :total => 1
+        response = mock_response total: 1
 
         html = page_entries_info(response)
         expect(html).to eq "<strong>1</strong> entry found"
@@ -65,8 +64,8 @@ describe CatalogHelper do
       end
 
       it "uses the model_name from the response" do
-        response = mock_response :total => 1
-        allow(response).to receive(:model_name).and_return(double(:human => 'thingy'))
+        response = mock_response total: 1
+        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"
@@ -75,55 +74,57 @@ describe CatalogHelper do
     end
 
     it "with a single page of results" do
-      response = mock_response :total => 7
+      response = mock_response total: 7
 
-      html = page_entries_info(response, { :entry_name => 'entry_name' })
+      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).to be_html_safe
     end
 
     it "on the first page of multiple pages of results" do
-      @response = mock_response :total => 15, :per_page => 10
+      @response = mock_response total: 15, per_page: 10
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      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).to be_html_safe
     end
 
     it "on the second page of multiple pages of results" do
-      @response = mock_response :total => 47, :per_page => 10, :current_page => 2
+      @response = mock_response total: 47, per_page: 10, current_page: 2
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      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).to be_html_safe
     end
 
     it "on the last page of results" do
-      @response = mock_response :total => 47, :per_page => 10, :current_page => 5
+      @response = mock_response total: 47, per_page: 10, current_page: 5
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      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).to be_html_safe
     end
     it "works with rows the same as per_page" do
-      @response = mock_response :total => 47, :rows => 20, :current_page => 2
+      @response = mock_response total: 47, rows: 20, current_page: 2
 
-      html = page_entries_info(@response, { :entry_name => 'entry_name' })
+      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).to be_html_safe
     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' })
+      @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
 
     context "with an ActiveRecord collection" do
+      subject { helper.page_entries_info(Bookmark.page(1).per(25)) }
+
       let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345' }
+
       before { 50.times { Bookmark.create!(user: user) } }
-      subject { helper.page_entries_info(Bookmark.page(1).per(25)) }
 
       it { is_expected.to eq "<strong>1</strong> - <strong>25</strong> of <strong>50</strong>" }
     end
@@ -174,6 +175,10 @@ describe CatalogHelper do
   end
 
   describe "should_autofocus_on_search_box?" do
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
     it "is 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", has_search_parameters?: false)
       expect(helper.should_autofocus_on_search_box?).to be true
@@ -196,102 +201,81 @@ describe CatalogHelper do
   end
 
   describe "has_thumbnail?" do
-    let(:document) { instance_double(SolrDocument) }
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
+    let(:document) { SolrDocument.new(data) }
+    let(:data) { {} }
+
     it "has a thumbnail if a thumbnail_method is configured" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      expect(helper.has_thumbnail? document).to be true
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_method: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
+      expect(helper.has_thumbnail?(document)).to be true
     end
 
-    it "has a thumbnail if a thumbnail_field is configured and it exists in the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-      allow(document).to receive_messages(has?: true)
-      expect(helper.has_thumbnail? document).to be true
+    context "if a thumbnail_field is configured and it exists in the document" do
+      let(:data) { { xyz: 'abc' } }
+
+      it "has a thumbnail" do
+        allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
+        expect(helper.has_thumbnail?(document)).to be true
+      end
     end
-    
+
     it "does not have a thumbnail if the thumbnail_field is missing from the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz, document_presenter_class: Blacklight::IndexPresenter)))
       allow(document).to receive_messages(has?: false)
-      expect(helper.has_thumbnail? document).to be false
+      expect(helper.has_thumbnail?(document)).to be false
     end
 
     it "does not have a thumbnail if none of the fields are configured" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
-      expect(helper.has_thumbnail? document).to be_falsey
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(document_presenter_class: Blacklight::IndexPresenter)))
+      expect(helper).not_to have_thumbnail(document)
     end
   end
 
   describe "render_thumbnail_tag" do
-    let(:document) { instance_double(SolrDocument) }
-    it "calls the provided thumbnail method" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      expect(helper).to receive_messages(:xyz => "some-thumbnail")
-
-      allow(helper).to receive(:link_to_document).with(document, "some-thumbnail", {})
-      helper.render_thumbnail_tag document
+    let(:index_presenter) do
+      instance_double(Blacklight::IndexPresenter, thumbnail: thumbnail_presenter)
     end
+    let(:thumbnail_presenter) { instance_double(Blacklight::ThumbnailPresenter) }
 
-    it "creates an image tag from the given field" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-
-      allow(document).to receive(:has?).with(:xyz).and_return(true)
-      allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
-
-      expect(helper).to receive(:link_to_document).with(document, image_tag("http://example.com/some.jpg"), {})
-      helper.render_thumbnail_tag document
-    end
-
-    it "does not link to the document if the url options are false" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => "some-thumbnail")
+    before do
       expect(Deprecation).to receive(:warn)
-      result = helper.render_thumbnail_tag document, {}, false
-      expect(result).to eq "some-thumbnail"
-    end
-
-    it "does not link to the document if the url options have :suppress_link" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => "some-thumbnail")
-
-      result = helper.render_thumbnail_tag document, {}, suppress_link: true
-      expect(result).to eq "some-thumbnail"
+      allow(helper).to receive(:index_presenter).with(document).and_return(index_presenter)
     end
 
+    let(:document) { instance_double(SolrDocument) }
 
-    it "returns nil if no thumbnail is available" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new() ))
-      expect(helper.render_thumbnail_tag document).to be_nil
+    it "calls thumbnail presenter with default values" do
+      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, {})
+      helper.render_thumbnail_tag document
     end
 
-    it "returns nil if no thumbnail is returned from the thumbnail method" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_method => :xyz) ))
-      allow(helper).to receive_messages(:xyz => nil)
-
-      expect(helper.render_thumbnail_tag document).to be_nil
-    end
-
-    it "returns nil if no thumbnail is in the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
-
-      allow(document).to receive(:has?).with(:xyz).and_return(false)
-
-      expect(helper.render_thumbnail_tag document).to be_nil
+    it "calls thumbnail presenter with provided values" do
+      expect(thumbnail_presenter).to receive(:thumbnail_tag).with({}, suppress_link: true)
+      helper.render_thumbnail_tag document, {}, suppress_link: true
     end
   end
 
   describe "thumbnail_url" do
+    before do
+      expect(Deprecation).to receive(:warn)
+    end
+
     it "pulls the configured thumbnail field out of the document" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
       document = instance_double(SolrDocument)
       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")
+      expect(helper.thumbnail_url(document)).to eq("asdf")
     end
 
     it "returns nil if the thumbnail field doesn't exist" do
-      allow(helper).to receive_messages(:blacklight_config => Blacklight::Configuration.new(:index => Blacklight::OpenStructWithHashAccess.new(:thumbnail_field => :xyz) ))
+      allow(helper).to receive_messages(blacklight_config: Blacklight::Configuration.new(index: Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)))
       document = instance_double(SolrDocument)
       allow(document).to receive(:has?).with(:xyz).and_return(false)
-      expect(helper.thumbnail_url document).to be_nil
+      expect(helper.thumbnail_url(document)).to be_nil
     end
   end
 
@@ -325,38 +309,37 @@ describe CatalogHelper do
 
     it "pulls data out of a document's field" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => 'book' }
+      doc = { type: 'book' }
       expect(helper.render_document_class(doc)).to eq "blacklight-book"
     end
 
     it "supports multivalued fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => ['book', 'mss'] }
+      doc = { type: %w[book mss] }
       expect(helper.render_document_class(doc)).to eq "blacklight-book blacklight-mss"
     end
 
     it "supports empty fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { :type => [] }
+      doc = { type: [] }
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports missing fields" do
       blacklight_config.index.display_type_field = :type
-      doc = { }
+      doc = {}
       expect(helper.render_document_class(doc)).to be_blank
     end
 
     it "supports view-specific field configuration" do
       allow(helper).to receive(:document_index_view_type).and_return(:some_view_type)
       blacklight_config.view.some_view_type.display_type_field = :other_type
-      doc = { other_type: "document"}
+      doc = { other_type: "document" }
       expect(helper.render_document_class(doc)).to eq "blacklight-document"
     end
   end
 
   describe "#bookmarked?" do
-
     let(:bookmark) { Bookmark.new document: bookmarked_document }
     let(:bookmarked_document) { SolrDocument.new(id: 'a') }
 
@@ -387,24 +370,25 @@ describe CatalogHelper do
     end
 
     it "renders a facet with two values" do
-      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz'])).to eq "Foo: bar and baz"
+      expect(helper.render_search_to_page_title_filter('foo', %w[bar baz])).to eq "Foo: bar and baz"
     end
 
     it "renders a facet with more than two values" do
-      expect(helper.render_search_to_page_title_filter('foo', ['bar', 'baz', 'foobar'])).to eq "Foo: 3 selected"
+      expect(helper.render_search_to_page_title_filter('foo', %w[bar baz foobar])).to eq "Foo: 3 selected"
     end
   end
 
   describe "#render_search_to_page_title" do
+    subject { helper.render_search_to_page_title(params) }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-      allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(:key => 'default_search_field', :display_label => 'Default'))
+      allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(key: 'default_search_field', display_label: 'Default'))
       allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
     end
 
     let(:blacklight_config) { Blacklight::Configuration.new }
     let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: ["Book"] }) }
-    subject { helper.render_search_to_page_title(params) }
 
     it { is_expected.to eq "foobar / Format: Book" }
   end

data/spec/i18n_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'i18n/tasks'
+
+RSpec.describe 'I18n', type: :i18n do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:missing_keys) { i18n.missing_keys }
+  let(:unused_keys) { i18n.unused_keys }
+
+  it 'does not have missing keys' do
+    expect(missing_keys).to be_empty,
+                            "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
+  end
+
+  pending 'does not have unused keys' do
+    expect(unused_keys).to be_empty,
+                           "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
+  end
+end

data/spec/integration/generators/blacklight/{solr5_generator_spec.rb → solr_generator_spec.rb}

@@ -1,19 +1,22 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
-require 'generators/blacklight/solr5_generator'
+require 'generators/blacklight/solr_generator'
 
-describe Blacklight::Solr5Generator do
+RSpec.describe Blacklight::SolrGenerator do
   let(:destination) { Dir.mktmpdir }
 
   describe "#solr_wrapper_config" do
     let(:generator) { described_class.new }
-    let(:files_to_test) {[
-        File.join("#{destination}", '.solr_wrapper.yml')
-    ]}
+    let(:files_to_test) do
+      [
+        File.join(destination.to_s, '.solr_wrapper.yml')
+      ]
+    end
 
     before do
       generator.destination_root = destination
       generator.solr_wrapper_config
-
     end
 
     after do
@@ -29,12 +32,17 @@ describe Blacklight::Solr5Generator do
 
   describe "#copy_solr_conf" do
     let(:generator) { described_class.new }
-    let(:dirs_to_test) {[
-        File.join("#{destination}", 'solr'),
-        File.join("#{destination}", 'solr/conf')]}
-    let(:files_to_test) {[
-        File.join("#{destination}", 'solr/conf/solrconfig.xml')
-    ]}
+    let(:dirs_to_test) do
+      [
+        File.join(destination.to_s, 'solr'),
+        File.join(destination.to_s, 'solr/conf')
+      ]
+    end
+    let(:files_to_test) do
+      [
+        File.join(destination.to_s, 'solr/conf/solrconfig.xml')
+      ]
+    end
 
     before do
       generator.destination_root = destination
@@ -57,4 +65,4 @@ describe Blacklight::Solr5Generator do
       end
     end
   end
-end
+end

data/spec/lib/blacklight/configuration/facet_field_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Configuration::FacetField do
+  describe 'link_to_search' do
+    subject { described_class.new(link_to_search: true) }
+
+    it 'is deprecated' do
+      expect(Deprecation).to receive(:warn)
+      expect(subject.normalize!)
+      expect(subject.link_to_facet).to eq true
+    end
+  end
+end

data/spec/lib/blacklight/configuration/field_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Configuration::Field do
+  subject { described_class.new(key: key, label: label) }
+
+  let(:key) { 'some_key' }
+  let(:label) { 'some label' }
+
+  describe '#display_label' do
+    it "looks up the label to display for the given document and field" do
+      allow(I18n).to receive(:t).with(:"blacklight.search.fields.my_context.some_key", default: [:"blacklight.search.fields.some_key", label, subject.default_label]).and_return('x')
+      expect(subject.display_label('my_context')).to eq 'x'
+    end
+  end
+end

data/spec/lib/blacklight/nested_open_struct_with_hash_access_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::NestedOpenStructWithHashAccess do
+  describe "#deep_dup" do
+    it "preserves the current class" do
+      expect(described_class.new(described_class).deep_dup).to be_a_kind_of described_class
+    end
+
+    it "preserves the default proc" do
+      nested = described_class.new Hash
+
+      copy = nested.deep_dup
+      copy.a[:b] = 1
+      expect(copy.a[:b]).to eq 1
+    end
+  end
+end

data/spec/lib/blacklight/open_struct_with_hash_access_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::OpenStructWithHashAccess do
+  it "provides hash-like accessors for OpenStruct data" do
+    a = described_class.new foo: :bar, baz: 1
+
+    expect(a[:foo]).to eq :bar
+    expect(a[:baz]).to eq 1
+    expect(a[:asdf]).to be_nil
+  end
+
+  it "provides hash-like writers for OpenStruct data" do
+    a = described_class.new foo: :bar, baz: 1
+
+    a[:asdf] = 'qwerty'
+    expect(a.asdf).to eq 'qwerty'
+  end
+
+  it "treats symbols and strings interchangeably in hash access" do
+    h = described_class.new
+
+    h["string"] = "value"
+    expect(h[:string]).to eq "value"
+    expect(h.string).to eq "value"
+
+    h[:symbol] = "value"
+    expect(h["symbol"]).to eq "value"
+    expect(h.symbol).to eq "value"
+  end
+
+  describe "internal hash table" do
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "exposes the internal hash table" do
+      expect(@h.to_h).to be_a_kind_of(Hash)
+      expect(@h.to_h[:a]).to eq 1
+    end
+
+    it "exposes keys" do
+      expect(@h.keys).to include(:a, :b)
+    end
+  end
+
+  describe "#key?" do
+    subject do
+      h = described_class.new
+      h[:a] = 1
+      h[:b] = 2
+      h
+    end
+
+    it "is true if the key exists" do
+      expect(subject.key?(:a)).to eq true
+    end
+
+    it "is false if the key does not exist" do
+      expect(subject.key?(:c)).to eq false
+    end
+  end
+
+  describe "#replace" do
+    subject { described_class.new a: 1 }
+
+    it "can use #replace to reorder the hash" do
+      subject.replace b: 1
+      expect(subject.b).to eq 1
+    end
+  end
+
+  describe "#sort_by" do
+    subject { described_class.new c: 3, b: 1, a: 2 }
+
+    it "sorts the underlying hash" do
+      sorted = subject.sort_by { |_k, v| v }
+      expect(sorted.keys).to match_array [:b, :a, :c]
+    end
+  end
+
+  describe "#sort_by!" do
+    subject { described_class.new c: 3, b: 1, a: 2 }
+
+    it "sorts the underlying hash" do
+      subject.sort_by! { |_k, v| v }
+      expect(subject.keys).to match_array [:b, :a, :c]
+    end
+  end
+
+  describe "#merge" do
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "merges the object with a hash" do
+      expect(@h.merge(a: 'a')[:a]).to eq 'a'
+    end
+
+    it "merges the object with another struct" do
+      expect(@h.merge(described_class.new(a: 'a'))[:a]).to eq 'a'
+    end
+  end
+
+  describe "#merge!" do
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "merges the object with a hash" do
+      @h[:a] = 'a'
+      expect(@h[:a]).to eq 'a'
+    end
+
+    it "merges the object with another struct" do
+      @h.merge!(described_class.new(a: 'a'))
+      expect(@h[:a]).to eq 'a'
+    end
+  end
+
+  describe "#to_json" do
+    subject { described_class.new a: 1, b: 2 }
+
+    it "serializes as json" do
+      expect(subject.to_json).to eq({ a: 1, b: 2 }.to_json)
+    end
+  end
+
+  describe "#deep_dup" do
+    subject { described_class.new a: 1, b: { c: 1 } }
+
+    it "duplicates nested hashes" do
+      copy = subject.deep_dup
+      copy.a = 2
+      copy.b[:c] = 2
+
+      expect(subject.a).to eq 1
+      expect(subject.b[:c]).to eq 1
+      expect(copy.a).to eq 2
+      expect(copy.b[:c]).to eq 2
+    end
+  end
+end

data/spec/lib/blacklight/parameters_spec.rb

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
-describe Blacklight::Parameters do
+RSpec.describe Blacklight::Parameters do
   describe "sanitize_search_params" do
     subject { described_class.sanitize(params) }
 
     context "with nil values" do
       let(:params) { ActionController::Parameters.new a: nil, b: 1 }
+
       it "removes them" do
-        expect(subject).to_not have_key(:a)
+        expect(subject).not_to have_key(:a)
         expect(subject[:b]).to eq 1
       end
     end
 
     context "with blacklisted keys" do
       let(:params) { ActionController::Parameters.new action: true, controller: true, id: true, commit: true, utf8: true }
+
       it "removes them" do
         expect(subject).to be_empty
       end