blacklight 6.14.0 → 7.0.0

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

data/spec/lib/blacklight_spec.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-describe Blacklight do
+RSpec.describe Blacklight do
   context 'root' do
-    let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..' )) }
+    let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..')) }
 
     it 'returns the full path to the BL plugin' do
-      expect(Blacklight.root).to eq blroot
+      expect(described_class.root).to eq blroot
     end
   end
 
   describe '.default_index' do
     context 'for a solr index' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'solr')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'solr')
       end
 
       it 'is an instance of Blacklight::Solr::Repository' do
-        expect(Blacklight.default_index).to be_a Blacklight::Solr::Repository
+        expect(described_class.default_index).to be_a Blacklight::Solr::Repository
       end
     end
   end
@@ -24,51 +24,50 @@ describe Blacklight do
   describe '.repository_class' do
     context 'when the adapter key is missing' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return({})
+        allow(described_class).to receive(:connection_config).and_return({})
       end
 
       it 'raises an error' do
-        expect { Blacklight.repository_class }.to raise_error RuntimeError, 'The value for :adapter was not found in the blacklight.yml config'
+        expect { described_class.repository_class }.to raise_error RuntimeError, 'The value for :adapter was not found in the blacklight.yml config'
       end
     end
 
     context 'for a solr index' do
       before do
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'solr')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'solr')
       end
 
       it 'resolves to the SolrRepository implementation' do
-        expect(Blacklight.repository_class).to eq Blacklight::Solr::Repository
+        expect(described_class.repository_class).to eq Blacklight::Solr::Repository
       end
     end
 
     context 'for an elastic_search index' do
       before do
         stub_const("Blacklight::ElasticSearch::Repository", double)
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'elastic_search')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'elastic_search')
       end
 
       it 'resolves to the SolrRepository implementation' do
-        expect(Blacklight.repository_class).to eq Blacklight::ElasticSearch::Repository
+        expect(described_class.repository_class).to eq Blacklight::ElasticSearch::Repository
       end
     end
 
     context 'for an explicitly provided class' do
       before do
         stub_const("CustomSearch::Repository", double)
-        allow(Blacklight).to receive(:connection_config).and_return(adapter: 'CustomSearch::Repository')
+        allow(described_class).to receive(:connection_config).and_return(adapter: 'CustomSearch::Repository')
       end
 
       it 'resolves to the custom implementation' do
-        expect(Blacklight.repository_class).to eq CustomSearch::Repository
+        expect(described_class.repository_class).to eq CustomSearch::Repository
       end
     end
   end
 
   describe '.default_configuration' do
     it 'is a Blacklight configuration' do
-      expect(Blacklight.default_configuration).to be_a Blacklight::Configuration
+      expect(described_class.default_configuration).to be_a Blacklight::Configuration
     end
   end
-  
 end

data/spec/lib/tasks/blacklight_task_spec.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 require 'rake'
 
-describe "blacklight:delete_old_searches" do
-
+RSpec.describe "blacklight:delete_old_searches" do
   before do
-    @rake = Rake::Application.new      
+    @rake = Rake::Application.new
     Rake.application = @rake
     Rake.application.rake_require "../lib/railties/blacklight"
     Rake::Task.define_task(:environment)
     @task_name = "blacklight:delete_old_searches"
   end
-  
+
   it "calls Search.delete_old_searches" do
     days_old = 7
-    allow(Search).to receive(:delete_old_searches).with(days_old)  
+    allow(Search).to receive(:delete_old_searches).with(days_old)
     @rake[@task_name].invoke(days_old)
   end
-    
 end

data/spec/models/blacklight/configurable_spec.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Configurable" do
-
+RSpec.describe "Blacklight::Configurable", api: true do
   describe "inheritence" do
     before(:all) do
       module TestCaseInheritence
@@ -9,7 +8,7 @@ describe "Blacklight::Configurable" do
           include Blacklight::Configurable
 
           blacklight_config.configure do |config|
-            config.list = [1,2,3]
+            config.list = [1, 2, 3]
           end
         end
 
@@ -17,23 +16,23 @@ describe "Blacklight::Configurable" do
         end
       end
     end
-    it "inherits the configuration when subclassed" do            
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1,2,3)
+
+    it "inherits the configuration when subclassed" do
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include(1, 2, 3)
     end
-    
-    it "inherited version should be a deep copy, not original" do      
-      expect(TestCaseInheritence::Child.blacklight_config).to_not  be(TestCaseInheritence::Parent.blacklight_config)
-    
-      TestCaseInheritence::Child.blacklight_config.list << "child_only"
 
+    it "inherited version should be a deep copy, not original" do
+      expect(TestCaseInheritence::Child.blacklight_config).not_to  be(TestCaseInheritence::Parent.blacklight_config)
 
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")      
-      expect(TestCaseInheritence::Parent.blacklight_config.list).to_not include("child_only")
-    end    
+      TestCaseInheritence::Child.blacklight_config.list << "child_only"
+
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")
+      expect(TestCaseInheritence::Parent.blacklight_config.list).not_to include("child_only")
+    end
   end
 
   describe "default configuration" do
-    before(:each) do
+    before do
       Blacklight::Configurable.default_configuration = nil
     end
 
@@ -51,20 +50,20 @@ describe "Blacklight::Configurable" do
     it "allows the user to provide a default configuration" do
       a = Class.new
 
-      Blacklight::Configurable.default_configuration = Blacklight::Configuration.new :a => 1
+      Blacklight::Configurable.default_configuration = Blacklight::Configuration.new a: 1
 
       a.send(:include, Blacklight::Configurable)
       expect(a.blacklight_config.a).to eq 1
     end
-    
+
     it "has configure_blacklight convenience method" do
       klass = Class.new
       klass.send(:include, Blacklight::Configurable)
-      
+
       klass.configure_blacklight do |config|
         config.my_key = 'value'
-      end 
-      
+      end
+
       expect(klass.blacklight_config.my_key).to eq 'value'
     end
 
@@ -75,11 +74,11 @@ describe "Blacklight::Configurable" do
 
       instance = klass.new
       instance.blacklight_config = Blacklight::Configuration.new
-      
-      expect(instance.blacklight_config).to_not eq klass.blacklight_config
+
+      expect(instance.blacklight_config).not_to eq klass.blacklight_config
       expect(instance.blacklight_config.foo).to be_nil
     end
-    
+
     it "allows instance to set it's own config seperate from class" do
       # this is built into class_attribute; we spec it both to document it,
       # and to ensure we preserve this feature if we change implementation
@@ -89,13 +88,13 @@ describe "Blacklight::Configurable" do
       klass.blacklight_config.foo = "bar"
       klass.blacklight_config.bar = []
       klass.blacklight_config.bar << "asd"
-      
+
       instance = klass.new
       instance.blacklight_config.bar << "123"
-      expect(instance.blacklight_config).to_not eq klass.blacklight_config
+      expect(instance.blacklight_config).not_to eq klass.blacklight_config
       expect(klass.blacklight_config.foo).to eq "bar"
       expect(instance.blacklight_config.foo).to eq  "bar"
-      expect(klass.blacklight_config.bar).to_not include("123")
+      expect(klass.blacklight_config.bar).not_to include("123")
       expect(instance.blacklight_config.bar).to include("asd", "123")
     end
 
@@ -111,7 +110,5 @@ describe "Blacklight::Configurable" do
       expect(klass.blacklight_config.foo).to eq "bar"
       expect(klass2.blacklight_config.foo).to eq "asdf"
     end
-    
   end
 end
-  

data/spec/models/blacklight/configuration/context_spec.rb

@@ -1,33 +1,32 @@
 # frozen_string_literal: true
 
-describe Blacklight::Configuration::Context do
-
+RSpec.describe Blacklight::Configuration::Context, api: true do
   subject { described_class.new(context) }
+
   let(:context) { double }
 
   describe "#evaluate_configuration_conditional" do
-    it "should pass through regular values" do
+    it "passes through regular values" do
       val = double
       expect(subject.evaluate_configuration_conditional(val)).to eq val
     end
 
-    it "should execute a helper method" do
-      allow(context).to receive_messages(:my_check => true)
+    it "executes a helper method" do
+      allow(context).to receive_messages(my_check: true)
       expect(subject.evaluate_configuration_conditional(:my_check)).to be true
     end
 
-    it "should call a helper to determine if it should render a field" do
+    it "calls a helper to determine if it should render a field" do
       a = double
       allow(context).to receive(:my_check_with_an_arg).with(a).and_return(true)
       expect(subject.evaluate_configuration_conditional(:my_check_with_an_arg, a)).to be true
     end
 
-    it "should evaluate a Proc to determine if it should render a field" do
-      one_arg_lambda = lambda { |context, a| true }
-      two_arg_lambda = lambda { |context, a, b| true }
+    it "evaluates a Proc to determine if it should render a field" do
+      one_arg_lambda = ->(_context, _a) { true }
+      two_arg_lambda = ->(_context, _a, _b) { true }
       expect(subject.evaluate_configuration_conditional(one_arg_lambda, 1)).to be true
       expect(subject.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be true
     end
   end
-
 end