blacklight 7.22.2 → 7.23.0

data/lib/blacklight/engine.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'view_component/engine'
+require 'blacklight/deprecations/engine_configuration'
+require 'view_component'
 
 module Blacklight
   class Engine < Rails::Engine
@@ -22,14 +23,18 @@ module Blacklight
       end
     end
 
-    initializer "blacklight.assets.precompile" do |app|
+    initializer "blacklight.assets.precompile" do
+      PRECOMPILE_ASSETS = %w(favicon.ico blacklight/blacklight.js blacklight/blacklight.js.map).freeze
+
       # When Rails has been generated in API mode, it does not have sprockets available
-      if defined? Sprockets
-        app.config.assets.precompile += %w(favicon.ico)
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += PRECOMPILE_ASSETS
       end
     end
 
-    Blacklight::Engine.config.sms_mappings = {
+    bl_global_config = OpenStructWithHashAccess.new
+
+    bl_global_config.sms_mappings = {
       'Virgin' => 'vmobl.com',
       'AT&T' => 'txt.att.net',
       'Verizon' => 'vtext.com',
@@ -41,14 +46,20 @@ module Blacklight
       'Google Fi' => 'msg.fi.google.com'
     }
 
-    config.bookmarks_http_method = :post
+    bl_global_config.bookmarks_http_method = :post
 
-    config.email_regexp = defined?(Devise) ? Devise.email_regexp : /\A[^@\s]+@[^@\s]+\z/
+    bl_global_config.email_regexp = defined?(Devise) ? Devise.email_regexp : /\A[^@\s]+@[^@\s]+\z/
 
-    config.action_dispatch.rescue_responses["Blacklight::Exceptions::RecordNotFound"] = :not_found
+    bl_global_config.facet_missing_param = '[* TO *]'
 
-    config.enable_search_bar_autofocus = false
+    # Anything that goes into Blacklight::Engine.config is stored as a class
+    # variable on Railtie::Configuration.  we're going to encapsulate all the
+    # Blacklight specific stuff in this single struct:
+    Blacklight::Engine.config.blacklight = bl_global_config
 
-    config.facet_missing_param = '[* TO *]'
+    # Deprecate top-level access to legacy engine configuration
+    Blacklight::Deprecations::EngineConfiguration.deprecate_in(Blacklight::Engine.config)
+
+    config.action_dispatch.rescue_responses["Blacklight::Exceptions::RecordNotFound"] = :not_found
   end
 end

data/lib/blacklight/exceptions.rb

@@ -15,6 +15,9 @@ module Blacklight
 
     class ECONNREFUSED < ::Errno::ECONNREFUSED; end
 
+    # NOTE: In Blacklight 8, the parent class will be Timeout::Error
+    class RepositoryTimeout < InvalidRequest; end
+
     class IconNotFound < StandardError
     end
   end

data/lib/blacklight/search_state/filter_field.rb

@@ -46,7 +46,7 @@ module Blacklight
 
         if value == Blacklight::SearchState::FilterField::MISSING
           url_key = "-#{key}"
-          value = Blacklight::Engine.config.facet_missing_param
+          value = Blacklight::Engine.config.blacklight.facet_missing_param
         end
 
         param = :f_inclusive if value.is_a?(Array)
@@ -82,7 +82,7 @@ module Blacklight
 
         if value == Blacklight::SearchState::FilterField::MISSING
           url_key = "-#{key}"
-          value = Blacklight::Engine.config.facet_missing_param
+          value = Blacklight::Engine.config.blacklight.facet_missing_param
         end
 
         param = :f_inclusive if value.is_a?(Array)
@@ -114,7 +114,7 @@ module Blacklight
         params = search_state.params
         f = Array(params.dig(:f, key))
         f_inclusive = [params.dig(:f_inclusive, key)] if params.dig(:f_inclusive, key).present?
-        f_missing = [Blacklight::SearchState::FilterField::MISSING] if params.dig(:f, "-#{key}")&.any? { |v| v == Blacklight::Engine.config.facet_missing_param }
+        f_missing = [Blacklight::SearchState::FilterField::MISSING] if params.dig(:f, "-#{key}")&.any? { |v| v == Blacklight::Engine.config.blacklight.facet_missing_param }
 
         f + (f_inclusive || []) + (f_missing || [])
       end
@@ -133,7 +133,7 @@ module Blacklight
         if value.is_a?(Array)
           (params.dig(:f_inclusive, key) || []).to_set == value.to_set
         elsif value == Blacklight::SearchState::FilterField::MISSING
-          (params.dig(:f, "-#{key}") || []).include?(Blacklight::Engine.config.facet_missing_param)
+          (params.dig(:f, "-#{key}") || []).include?(Blacklight::Engine.config.blacklight.facet_missing_param)
         else
           (params.dig(:f, key) || []).include?(value)
         end

data/lib/blacklight/solr/repository.rb

@@ -58,30 +58,40 @@ module Blacklight::Solr
     # @return [Blacklight::Solr::Response] the solr response object
     def send_and_receive(path, solr_params = {})
       benchmark("Solr fetch", level: :debug) do
-        res = if solr_params[:json].present?
-                connection.send_and_receive(
-                  path,
-                  data: { params: solr_params.to_hash.except(:json) }.merge(solr_params[:json]).to_json,
-                  method: :post,
-                  headers: { 'Content-Type' => 'application/json' }
-                )
-              else
-                key = blacklight_config.http_method == :post ? :data : :params
-                connection.send_and_receive(path, { key => solr_params.to_hash, method: blacklight_config.http_method })
-              end
-
+        res = connection.send_and_receive(path, build_solr_request(solr_params))
         solr_response = blacklight_config.response_model.new(res, solr_params, document_model: blacklight_config.document_model, blacklight_config: blacklight_config)
 
         Blacklight.logger&.debug("Solr query: #{blacklight_config.http_method} #{path} #{solr_params.to_hash.inspect}")
         Blacklight.logger&.debug("Solr response: #{solr_response.inspect}") if defined?(::BLACKLIGHT_VERBOSE_LOGGING) && ::BLACKLIGHT_VERBOSE_LOGGING
         solr_response
       end
+    rescue *defined_rsolr_timeout_exceptions => e
+      raise Blacklight::Exceptions::RepositoryTimeout, "Timeout connecting to Solr instance using #{connection.inspect}: #{e.inspect}"
     rescue Errno::ECONNREFUSED => e
+      # intended for and likely to be a RSolr::Error:ConnectionRefused, specifically.
       raise Blacklight::Exceptions::ECONNREFUSED, "Unable to connect to Solr instance using #{connection.inspect}: #{e.inspect}"
     rescue RSolr::Error::Http => e
       raise Blacklight::Exceptions::InvalidRequest, e.message
     end
 
+    # @return [Hash]
+    # @!visibility private
+    def build_solr_request(solr_params)
+      if solr_params[:json].present?
+        {
+          data: { params: solr_params.to_hash.except(:json) }.merge(solr_params[:json]).to_json,
+          method: :post,
+          headers: { 'Content-Type' => 'application/json' }
+        }
+      else
+        key = blacklight_config.http_method == :post ? :data : :params
+        {
+          key => solr_params.to_hash,
+          method: blacklight_config.http_method
+        }
+      end
+    end
+
     private
 
     ##
@@ -97,5 +107,19 @@ module Blacklight::Solr
     def build_connection
       RSolr.connect(connection_config.merge(adapter: connection_config[:http_adapter]))
     end
+
+    # RSolr 2.4.0+ has a RSolr::Error::Timeout that we'd like to treat specially
+    # instead of lumping into RSolr::Error::Http. Before that we can not rescue
+    # specially, so return an empty array.
+    #
+    # @return [Array<Exception>] that can be used, with a splat, as argument
+    #   to a ruby rescue
+    def defined_rsolr_timeout_exceptions
+      if defined?(RSolr::Error::Timeout)
+        [RSolr::Error::Timeout]
+      else
+        []
+      end
+    end
   end
 end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -355,10 +355,7 @@ module Blacklight::Solr
       solr_field ||= facet_field
 
       local_params = []
-
-      if use_local_params
-        local_params << "tag=#{facet_config.tag}" if facet_config && facet_config.tag
-      end
+      local_params << "tag=#{facet_config.tag}" if use_local_params && facet_config && facet_config.tag
 
       if facet_config && facet_config.query
         if facet_config.query[value]

data/lib/generators/blacklight/assets_generator.rb

@@ -11,15 +11,21 @@ module Blacklight
       gem 'twitter-typeahead-rails', '0.11.1.pre.corejavascript'
     end
 
-    # Add sprockets javascript to Rails 6.
-    def create_sprockets_javascript
-      return if Rails.version < '6.0.0'
+    def appease_rails7
+      return unless Rails.version > '7'
+
+      gem "sassc-rails", "~> 2.1"
 
+      remove_file 'app/javascript/application.js'
+    end
+
+    # Add sprockets javascript
+    def create_sprockets_javascript
       create_file 'app/assets/javascripts/application.js' do
         <<~CONTENT
           //= require jquery3
           //= require rails-ujs
-          //= require turbolinks
+          #{'//= require turbolinks' if Rails.version < '7'}
         CONTENT
       end
     end
@@ -40,6 +46,7 @@ module Blacklight
       # Ensure this method is idempotent
       return if has_blacklight_assets?
 
+      gem 'jquery-rails'
       contents = "\n//\n// Required by Blacklight\n"
       contents += "//= require popper\n"
       contents += "// Twitter Typeahead for autocomplete\n"
@@ -62,11 +69,6 @@ module Blacklight
       end
     end
 
-    # This is not a default in Rails 5.1+
-    def add_jquery
-      gem 'jquery-rails'
-    end
-
     private
 
     def turbolinks?
@@ -78,7 +80,9 @@ module Blacklight
     end
 
     def application_js
-      IO.read(File.expand_path("app/assets/javascripts/application.js", destination_root))
+      path = File.expand_path("app/assets/javascripts/application.js", destination_root)
+
+      File.exist?(path) ? File.read(path) : ''
     end
   end
 end

data/spec/components/blacklight/constraints_component_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::ConstraintsComponent, type: :component do
+  subject(:component) { described_class.new(**params) }
+
+  let(:rendered) { render_inline_to_capybara_node(component) }
+
+  let(:params) do
+    { search_state: search_state }
+  end
+
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.tap do |config|
+      config.add_facet_field 'some_facet'
+    end
+  end
+
+  let(:search_state) { Blacklight::SearchState.new(query_params.with_indifferent_access, blacklight_config) }
+  let(:query_params) { {} }
+
+  context 'with a query' do
+    let(:query_params) { { q: 'some query' } }
+
+    it 'renders a start-over link' do
+      expect(rendered).to have_link 'Start Over', href: '/catalog'
+    end
+
+    it 'has a header' do
+      expect(rendered).to have_selector('h2', text: 'Search Constraints')
+    end
+
+    it 'wraps the output in a div' do
+      expect(rendered).to have_selector('div#appliedParams')
+    end
+
+    it 'renders the query' do
+      expect(rendered).to have_selector('.applied-filter.constraint', text: 'some query')
+    end
+  end
+
+  context 'with a facet' do
+    let(:query_params) { { f: { some_facet: ['some value'] } } }
+
+    it 'renders the query' do
+      expect(rendered).to have_selector('.constraint-value > .filter-name', text: 'Some Facet').and(have_selector('.constraint-value > .filter-value', text: 'some value'))
+    end
+  end
+
+  describe '.for_search_history' do
+    subject(:component) { described_class.for_search_history(**params) }
+
+    let(:query_params) { { q: 'some query', f: { some_facet: ['some value'] } } }
+
+    it 'wraps the output in a span' do
+      expect(rendered).to have_selector('span .constraint')
+    end
+
+    it 'renders the search state as lightly-decorated text' do
+      expect(rendered).to have_selector('.constraint > .filter-values', text: 'some query').and(have_selector('.constraint', text: 'Some Facet:some value'))
+    end
+
+    it 'omits the headers' do
+      expect(rendered).not_to have_selector('h2', text: 'Search Constraints')
+    end
+  end
+end

data/spec/components/blacklight/document/action_component_spec.rb

@@ -24,10 +24,11 @@ RSpec.describe Blacklight::Document::ActionComponent, type: :component do
 
   it 'renders an action link' do
     if Rails.version >= '6'
-      allow(view_context).to receive(:some_tool_solr_document_path).with(document, only_path: true).and_return('/asdf')
+      allow(view_context).to receive(:some_tool_solr_document_path).with(document, { only_path: true }).and_return('/asdf')
     else
       allow(view_context).to receive(:some_tool_solr_document_path).with(document).and_return('/asdf')
     end
+
     expect(rendered).to have_link 'Some tool', href: '/asdf'
   end
 

data/spec/components/blacklight/document_component_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
     CatalogController.blacklight_config.deep_copy.tap do |config|
       config.track_search_session = false
       config.index.thumbnail_field = 'thumbnail_path_ss'
-      config.index.document_actions[:bookmark].partial = '/catalog/bookmark_control.html.erb'
+      config.index.document_actions[:bookmark].partial = '/catalog/bookmark_control'
     end
   end
 

data/spec/components/blacklight/response/spellcheck_component_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::Response::SpellcheckComponent, type: :component do
+  subject(:render) { render_inline(instance) }
+
+  let(:spellcheck_options) { nil }
+  let(:instance) { described_class.new(response: response, options: spellcheck_options) }
+  let(:config) do
+    Blacklight::Configuration.new do |config|
+      config.spell_max = 5
+    end
+  end
+
+  before do
+    allow(controller).to receive(:blacklight_config).and_return(config)
+  end
+
+  context 'when there are many results' do
+    let(:response) { instance_double(Blacklight::Solr::Response, total: 10, spelling: double(words: [1], collation: nil)) }
+
+    it "does not show suggestions" do
+      expect(render.to_html).to be_blank
+    end
+  end
+
+  context 'when there are only a few results' do
+    let(:word_suggestion) { 'yoshida' }
+    let(:response) { instance_double(Blacklight::Solr::Response, total: 4, spelling: double(words: [word_suggestion], collation: nil)) }
+
+    it "shows suggestions" do
+      expect(render.to_html).to include(word_suggestion)
+    end
+
+    context 'and explicit spellcheck options' do
+      let(:explicit_option) { 'explicit option' }
+      let(:spellcheck_options) { [explicit_option] }
+
+      it "shows only explicit suggestions" do
+        expect(render.to_html).to include(explicit_option)
+        expect(render.to_html).not_to include(word_suggestion)
+      end
+    end
+
+    context 'and collations are present' do
+      let(:word_suggestion) { 'donotuse' }
+      let(:collated_suggestion) { 'yoshida Hajime' }
+      let(:response) { instance_double(Blacklight::Solr::Response, total: 4, spelling: double(words: [word_suggestion], collation: collated_suggestion)) }
+
+      it "shows only collated suggestions" do
+        expect(render.to_html).to include(collated_suggestion)
+        expect(render.to_html).not_to include(word_suggestion)
+      end
+    end
+  end
+
+  context 'when there are no spelling suggestions' do
+    let(:response) { instance_double(Blacklight::Solr::Response, total: 4, spelling: double(words: [], collation: nil)) }
+
+    it "does not show suggestions" do
+      expect(render.to_html).to be_blank
+    end
+  end
+
+  context 'when spelling is not available' do
+    let(:response) { instance_double(Blacklight::Solr::Response, total: 4, spelling: nil) }
+
+    it "does not show suggestions" do
+      expect(render.to_html).to be_blank
+    end
+  end
+end

data/spec/components/blacklight/start_over_button_component_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::StartOverButtonComponent, type: :component do
+  subject(:render) { render_inline(instance) }
+
+  let(:instance) { described_class.new }
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.view = { list: nil, abc: nil }
+    end
+  end
+
+  before do
+    allow(controller).to receive(:blacklight_config).and_return(blacklight_config)
+  end
+
+  context 'with the current view type' do
+    before do
+      controller.params[:view] = 'abc'
+    end
+
+    it 'is the catalog path' do
+      expect(render.css('a').first['href']).to eq '/catalog?view=abc'
+    end
+  end
+
+  context 'when the current view type is the default' do
+    before do
+      controller.params[:view] = 'list'
+    end
+
+    it 'does not include the current view type' do
+      expect(render.css('a').first['href']).to eq '/catalog'
+    end
+  end
+end

data/spec/controllers/catalog_controller_spec.rb

@@ -788,7 +788,7 @@ RSpec.describe CatalogController, api: true do
   describe "#add_show_tools_partial", api: false do
     before do
       described_class.blacklight_config.add_show_tools_partial(:like, callback: :perform_like, validator: :validate_like_params)
-      allow(controller).to receive(:solr_document_url).and_return('catalog/1')
+      allow(controller).to receive(:solr_document_url).and_return('http://test.host/catalog/1')
       allow(controller).to receive(:action_documents).and_return(1)
       Rails.application.routes.draw do
         get 'catalog/like', as: :catalog_like

data/spec/features/did_you_mean_spec.rb

@@ -127,4 +127,25 @@ RSpec.describe "Did You Mean" do
     click_button 'search'
     expect(page).to have_content("Did you mean")
   end
+
+  context 'spellcheck collations are enabled' do
+    before do
+      CatalogController.blacklight_config[:default_solr_params]["spellcheck.collate"] = true
+    end
+
+    after do
+      CatalogController.blacklight_config[:default_solr_params].delete("spellcheck.collate")
+    end
+
+    it "shows suggestions if there aren't many hits" do
+      fill_in "q", with: 'Yoshido Hajime'
+      click_button 'search'
+
+      expect(page).to have_content("Did you mean")
+      click_link 'yoshida Hajime'
+      within ("#sortAndPerPage") do
+        expect(page).to have_content "1 - 2 of 2"
+      end
+    end
+  end
 end

data/spec/features/search_context_spec.rb

@@ -3,13 +3,14 @@
 RSpec.describe "Search Results context", js: true do
   it "passes the current search id through" do
     search_for ''
-    search_id = Search.last.id.to_s
     click_on 'Pluvial nectar of blessings'
+    search_id = Search.last.id.to_s
     expect(page).to have_content "« Previous | 10 of 30 | Next »"
     prev = page.find(".pagination-search-widgets .previous")
     expect(prev['data-context-href']).to eq "/catalog/2003546302/track?counter=9&document_id=2003546302&search_id=#{search_id}"
 
     click_on "« Previous"
+    expect(page).to have_content "U21.2 .W85 2003"
 
     prev = page.find(".pagination-search-widgets .previous")
     expect(prev['data-context-href']).to eq "/catalog/2004310986/track?counter=8&document_id=2004310986&search_id=#{search_id}"
@@ -48,6 +49,7 @@ RSpec.describe "Search Results context", js: true do
       find_all('.index_title a').last.click
       click_on "Next »"
 
+      expect(page).to have_content "Naqdī barā-yi tamām-i"
       click_on "Back to Search"
       expect(page).to have_content "11 - 20"
     end

data/spec/helpers/blacklight/search_history_constraints_helper_behavior_spec.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
+  around { |test| Deprecation.silence(described_class) { test.call } }
+
   before(:all) do
     @config = Blacklight::Configuration.new do |config|
       config.add_search_field 'default_search_field', label: 'Default'

data/spec/helpers/blacklight/url_helper_behavior_spec.rb

@@ -133,7 +133,7 @@ RSpec.describe Blacklight::UrlHelperBehavior do
 
       it "calls url_for on the engine scope" do
         expect(my_engine).to receive(:url_for)
-          .with(q: "query", f: "facets", controller: "catalog")
+          .with({ q: "query", f: "facets", controller: "catalog" })
           .and_return('link-url')
         expect(tag).to match /Back to Search/
         expect(tag).to match /link-url/
@@ -292,12 +292,12 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     let(:document) { SolrDocument.new(id: 1) }
 
     it "determines the correct route for the document class" do
-      allow(helper.main_app).to receive(:track_test_path).with(id: have_attributes(id: 1)).and_return('x')
+      allow(helper.main_app).to receive(:track_test_path).with({ id: have_attributes(id: 1) }).and_return('x')
       expect(helper.session_tracking_path(document)).to eq 'x'
     end
 
     it "passes through tracking parameters" do
-      allow(helper.main_app).to receive(:track_test_path).with(id: have_attributes(id: 1), x: 1).and_return('x')
+      allow(helper.main_app).to receive(:track_test_path).with({ id: have_attributes(id: 1), x: 1 }).and_return('x')
       expect(helper.session_tracking_path(document, x: 1)).to eq 'x'
     end
 

data/spec/helpers/blacklight_helper_spec.rb

@@ -82,7 +82,7 @@ RSpec.describe BlacklightHelper do
     end
 
     it "sends parameters" do
-      expect(presenter).to receive(:link_rel_alternates).with(unique: true).and_return(result)
+      expect(presenter).to receive(:link_rel_alternates).with({ unique: true }).and_return(result)
       expect(helper.render_link_rel_alternates(document, unique: true)).to eq result
     end
   end
@@ -264,8 +264,13 @@ RSpec.describe BlacklightHelper do
       expect(helper.should_show_spellcheck_suggestions?(response)).to be true
     end
 
+    it "only shows suggestions from collations" do
+      response = double(total: 4, spelling: double(words: [], collation: { blah: 1 }))
+      expect(helper.should_show_spellcheck_suggestions?(response)).to be true
+    end
+
     it "shows suggestions only if there are spelling suggestions available" do
-      response = double(total: 4, spelling: double(words: []))
+      response = double(total: 4, spelling: double(words: [], collation: nil))
       expect(helper.should_show_spellcheck_suggestions?(response)).to be false
     end
 
@@ -298,7 +303,7 @@ RSpec.describe BlacklightHelper do
   describe "#render_document_index" do
     it "renders the document index with the current view type" do
       allow(helper).to receive_messages(document_index_view_type: :current_view)
-      allow(helper).to receive(:render_document_index_with_view).with(:current_view, [], a: 1, b: 2)
+      allow(helper).to receive(:render_document_index_with_view).with(:current_view, [], { a: 1, b: 2 })
       helper.render_document_index [], a: 1, b: 2
     end
   end

data/spec/helpers/catalog_helper_spec.rb

@@ -369,7 +369,7 @@ RSpec.describe CatalogHelper do
   end
 
   describe "#render_search_to_page_title" do
-    subject { helper.render_search_to_page_title(params) }
+    subject { helper.render_search_to_page_title(Blacklight::SearchState.new(params, blacklight_config)) }
 
     before do
       allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
@@ -377,7 +377,11 @@ RSpec.describe CatalogHelper do
       allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
     end
 
-    let(:blacklight_config) { Blacklight::Configuration.new }
+    let(:blacklight_config) do
+      Blacklight::Configuration.new.tap do |config|
+        config.add_facet_field 'format'
+      end
+    end
 
     context 'when the f param is an array' do
       let(:params) { ActionController::Parameters.new(q: 'foobar', f: { format: ["Book"] }) }

data/spec/lib/blacklight/engine_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Engine do
+  [:bookmarks_http_method, :email_regexp, :facet_missing_param, :sms_mappings].each do |dep_key|
+    describe "config.#{dep_key}" do
+      subject { described_class.config }
+
+      let(:unlikely_value) { 'unlikely value' }
+
+      it 'is deprecated' do
+        allow(Deprecation).to receive(:warn)
+        subject.send(dep_key)
+        expect(Deprecation).to have_received(:warn)
+      end
+
+      it 'delegates to config.blacklight' do
+        allow(subject.blacklight).to receive(dep_key).and_return(unlikely_value)
+        expect(subject.send(dep_key)).to eql(unlikely_value)
+      end
+    end
+
+    describe "config.#{dep_key}=" do
+      subject { described_class.config }
+
+      let(:unlikely_value) { 'unlikely value' }
+
+      it 'is deprecated' do
+        allow(Deprecation).to receive(:warn)
+        allow(subject.blacklight).to receive(:"#{dep_key}=").with(unlikely_value)
+        subject.send(:"#{dep_key}=", unlikely_value)
+        expect(Deprecation).to have_received(:warn)
+      end
+
+      it 'delegates to config.blacklight' do
+        allow(subject.blacklight).to receive(:"#{dep_key}=").with(unlikely_value)
+        subject.send(:"#{dep_key}=", unlikely_value)
+        expect(subject.blacklight).to have_received(:"#{dep_key}=").with(unlikely_value)
+      end
+    end
+  end
+end