blacklight 6.21.0 → 7.3.0

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

data/spec/lib/blacklight/search_state_spec.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
-describe Blacklight::SearchState do
+RSpec.describe Blacklight::SearchState do
+  subject(:search_state) { described_class.new(params, blacklight_config, controller) }
+
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.index.title_field = 'title_display'
+      config.index.title_field = 'title_tsim'
       config.index.display_type_field = 'format'
     end
   end
 
-  subject(:search_state) { described_class.new(params, blacklight_config, controller) }
   let(:parameter_class) { ActionController::Parameters }
   let(:controller) { double }
   let(:params) { parameter_class.new }
 
   describe '#to_h' do
-    let(:data) { { a: '1'} }
+    let(:data) { { a: '1' } }
     let(:params) { parameter_class.new data }
 
     it 'returns a copy of the original parameters' do
@@ -52,8 +53,8 @@ describe Blacklight::SearchState do
 
     it "takes original params" do
       result = search_state.params_for_search
-      expect(result).to eq({ 'default' => 'params' })
-      expect(params.object_id).to_not eq result.object_id
+      expect(result).to eq('default' => 'params')
+      expect(params.object_id).not_to eq result.object_id
     end
 
     it "accepts params to merge into the controller's params" do
@@ -63,15 +64,17 @@ describe Blacklight::SearchState do
 
     context "when params have blacklisted keys" do
       let(:params) { parameter_class.new action: 'action', controller: 'controller', id: "id", commit: 'commit' }
+
       it "removes them" do
         result = search_state.params_for_search
-        expect(result.keys).to_not include(:action, :controller, :commit, :id)
+        expect(result.keys).not_to include(:action, :controller, :commit, :id)
       end
     end
 
     context "when params has page" do
       context "and per_page changed" do
         let(:params) { parameter_class.new per_page: 20, page: 5 }
+
         it "adjusts the current page" do
           result = search_state.params_for_search(per_page: 100)
           expect(result[:page]).to eq 1
@@ -80,6 +83,7 @@ describe Blacklight::SearchState do
 
       context "and per_page didn't change" do
         let(:params) { parameter_class.new per_page: 20, page: 5 }
+
         it "doesn't change the current page" do
           result = search_state.params_for_search(per_page: 20)
           expect(result[:page]).to eq 5
@@ -88,6 +92,7 @@ describe Blacklight::SearchState do
 
       context "and the sort changes" do
         let(:params) { parameter_class.new sort: 'field_a', page: 5 }
+
         it "adjusts the current page" do
           result = search_state.params_for_search(sort: 'field_b')
           expect(result[:page]).to eq 1
@@ -96,6 +101,7 @@ describe Blacklight::SearchState do
 
       context "and the sort didn't change" do
         let(:params) { parameter_class.new sort: 'field_a', page: 5 }
+
         it "doesn't change the current page" do
           result = search_state.params_for_search(sort: 'field_a')
           expect(result[:page]).to eq 5
@@ -105,13 +111,14 @@ describe Blacklight::SearchState do
 
     context "with a block" do
       let(:params) { parameter_class.new a: 1, b: 2 }
+
       it "evalutes the block and allow it to add or remove keys" do
         result = search_state.params_for_search(c: 3) do |params|
           params.extract! :a, :b
           params[:d] = 'd'
         end
 
-        expect(result.keys).to_not include(:a, :b)
+        expect(result.keys).not_to include(:a, :b)
         expect(result[:c]).to eq 3
         expect(result[:d]).to eq 'd'
       end
@@ -121,19 +128,20 @@ describe Blacklight::SearchState do
   describe "add_facet_params" do
     let(:params_no_existing_facet) do
       parameter_class.new q: "query",
-                                       search_field: "search_field",
-                                       per_page: "50"
+                          search_field: "search_field",
+                          per_page: "50"
     end
     let(:params_existing_facets) do
       parameter_class.new q: "query",
-                                       search_field: "search_field",
-                                       per_page: "50",
-                                       f: { "facet_field_1" => ["value1"],
-                                            "facet_field_2" => ["value2", "value2a"] }
+                          search_field: "search_field",
+                          per_page: "50",
+                          f: { "facet_field_1" => ["value1"],
+                               "facet_field_2" => %w[value2 value2a] }
     end
 
     context "when there are no pre-existing facets" do
       let(:params) { params_no_existing_facet }
+
       it "adds facet value" do
         result_params = search_state.add_facet_params("facet_field", "facet_value")
         expect(result_params[:f]).to be_a Hash
@@ -144,8 +152,9 @@ describe Blacklight::SearchState do
       it "leaves non-facet params alone" do
         result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
 
-        params.each_pair do |key, value|
+        params.each_pair do |key, _value|
           next if key == :f
+
           expect(result_params[key]).to eq params[key]
         end
       end
@@ -162,12 +171,13 @@ describe Blacklight::SearchState do
 
     context "when there are pre-existing facets" do
       let(:params) { params_existing_facets }
+
       it "adds a facet param to existing facet constraints" do
         result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
 
         expect(result_params[:f]).to be_a Hash
 
-        params_existing_facets[:f].each_pair do |facet_field, value_list|
+        params_existing_facets[:f].each_pair do |facet_field, _value_list|
           expect(result_params[:f][facet_field]).to 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"])
@@ -180,8 +190,9 @@ describe Blacklight::SearchState do
       it "leaves non-facet params alone" do
         result_params = search_state.add_facet_params("facet_field_2", "new_facet_value")
 
-        params.each_pair do |key, value|
+        params.each_pair do |key, _value|
           next if key == 'f'
+
           expect(result_params[key]).to eq params[key]
         end
       end
@@ -189,6 +200,7 @@ describe Blacklight::SearchState do
 
     context "with a facet selected in the params" do
       let(:params) { parameter_class.new f: { 'single_value_facet_field' => 'other_value' } }
+
       it "replaces facets configured as single" do
         allow(search_state).to receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(single: true, key: "single_value_facet_field"))
         result_params = search_state.add_facet_params('single_value_facet_field', 'my_value')
@@ -205,14 +217,14 @@ describe Blacklight::SearchState do
     end
 
     it "defers to the field set on a FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(:field => 'facet_field_2', :value => 123))
+      result_params = search_state.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)
     end
 
     it "adds any extra fq parameters from the FacetItem" do
-      result_params = search_state.add_facet_params('facet_field_1', double(:value => 123, fq: { 'facet_field_2' => 'abc' }))
+      result_params = search_state.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')
@@ -220,29 +232,31 @@ describe Blacklight::SearchState do
   end
 
   describe "add_facet_params_and_redirect" do
-    let(:params) { parameter_class.new(
-                    q: "query",
-                    search_field: "search_field",
-                    per_page: "50",
-                    page: "5",
-                    f: { "facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"] },
-                    Blacklight::Solr::FacetPaginator.request_keys[:page] => "100",
-                    Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
-                    id: 'facet_field_name')
-    }
+    let(:params) do
+      parameter_class.new(
+        q: "query",
+        search_field: "search_field",
+        per_page: "50",
+        page: "5",
+        f: { "facet_field_1" => ["value1"], "facet_field_2" => %w[value2 value2a] },
+        Blacklight::Solr::FacetPaginator.request_keys[:page] => "100",
+        Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
+        id: 'facet_field_name'
+      )
+    end
 
     it "does not include request parameters used by the facet paginator" do
       params = search_state.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).to_not include(paginator_key)
+        expect(params.keys).not_to include(paginator_key)
       end
     end
 
     it 'removes :page request key' do
       params = search_state.add_facet_params_and_redirect("facet_field_2", "facet_value")
-      expect(params).to_not have_key(:page)
+      expect(params).not_to have_key(:page)
     end
 
     it "otherwise does the same thing as add_facet_params" do
@@ -255,9 +269,10 @@ describe Blacklight::SearchState do
 
   describe "#remove_facet_params" do
     let(:params) { parameter_class.new 'f' => facet_params }
-    let(:facet_params) { { } }
+    let(:facet_params) { {} }
+
     context "when the facet has multiple values" do
-      let(:facet_params) { { 'some_field' => ['some_value', 'another_value'] } }
+      let(:facet_params) { { 'some_field' => %w[some_value another_value] } }
 
       it "removes the facet / value tuple from the query parameters" do
         params = search_state.remove_facet_params('some_field', 'some_value')
@@ -280,9 +295,11 @@ describe Blacklight::SearchState do
     context "when the facet has configuration" do
       before do
         allow(search_state).to receive(:facet_configuration_for_field).with('some_field').and_return(
-          double(single: true, field: "a_solr_field", key: "some_key"))
+          double(single: true, field: "a_solr_field", key: "some_key")
+        )
       end
-      let(:facet_params) { { 'some_key' => ['some_value', 'another_value'] } }
+
+      let(:facet_params) { { 'some_key' => %w[some_value another_value] } }
 
       it "uses the facet's key configuration" do
         params = search_state.remove_facet_params('some_field', 'some_value')
@@ -313,7 +330,7 @@ describe Blacklight::SearchState do
     it 'returns a search state with the given parameters' do
       new_state = search_state.reset('a' => 1)
 
-      expect(new_state.to_hash).to eq({ 'a' => 1 })
+      expect(new_state.to_hash).to eq('a' => 1)
     end
   end
 end