blacklight 7.24.0 → 7.25.0

data/lib/blacklight/search_state/filter_field.rb

@@ -6,12 +6,22 @@ module Blacklight
     class FilterField
       MISSING = { missing: true }.freeze
 
-      # @param [Blacklight::Configuration::FacetField] config
+      # @!attribute config
+      #   @return [Blacklight::Configuration::FacetField]
       attr_reader :config
 
-      # @param [Blacklight::SearchState] search_state
+      # @!attribute search_state
+      #   @return [Blacklight::SearchState]
       attr_reader :search_state
 
+      # @!attribute param
+      #   @return [String,Symbol]
+      attr_reader :filters_key
+
+      # @!attribute inclusive_param
+      #   @return [String,Symbol]
+      attr_reader :inclusive_filters_key
+
       # @return [String,Symbol]
       delegate :key, to: :config
 
@@ -20,9 +30,11 @@ module Blacklight
       def initialize(config, search_state)
         @config = config
         @search_state = search_state
+        @filters_key = :f
+        @inclusive_filters_key = :f_inclusive
       end
 
-      # @param [String,#value] a filter item to add to the url
+      # @param [String,#value] item a filter item to add to the url
       # @return [Blacklight::SearchState] new state
       def add(item)
         new_state = search_state.reset_search
@@ -41,7 +53,7 @@ module Blacklight
 
         url_key = key
         params = new_state.params
-        param = :f
+        param = filters_key
         value = as_url_parameter(item)
 
         if value == Blacklight::SearchState::FilterField::MISSING
@@ -49,7 +61,7 @@ module Blacklight
           value = Blacklight::Engine.config.blacklight.facet_missing_param
         end
 
-        param = :f_inclusive if value.is_a?(Array)
+        param = inclusive_filters_key if value.is_a?(Array)
 
         # value could be a string
         params[param] = (params[param] || {}).dup
@@ -66,7 +78,7 @@ module Blacklight
         new_state.reset(params)
       end
 
-      # @param [String,#value] a filter to remove from the url
+      # @param [String,#value] item a filter to remove from the url
       # @return [Blacklight::SearchState] new state
       def remove(item)
         new_state = search_state.reset_search
@@ -77,7 +89,7 @@ module Blacklight
         url_key = config.key
         params = new_state.params
 
-        param = :f
+        param = filters_key
         value = as_url_parameter(item)
 
         if value == Blacklight::SearchState::FilterField::MISSING
@@ -85,7 +97,7 @@ module Blacklight
           value = Blacklight::Engine.config.blacklight.facet_missing_param
         end
 
-        param = :f_inclusive if value.is_a?(Array)
+        param = inclusive_filters_key if value.is_a?(Array)
 
         # need to dup the facet values too,
         # if the values aren't dup'd, then the values
@@ -110,17 +122,25 @@ module Blacklight
       end
 
       # @return [Array] an array of applied filters
-      def values
+      def values(except: [])
         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.blacklight.facet_missing_param }
+        return [] if params.blank?
+
+        f = except.include?(:filters) ? [] : [params.dig(filters_key, key)].flatten.compact
+        f_inclusive = [params.dig(:f_inclusive, key)] unless params.dig(inclusive_filters_key, key).blank? || except.include?(:inclusive_filters)
+        f_missing = [Blacklight::SearchState::FilterField::MISSING] if params.dig(filters_key, "-#{key}")&.any? { |v| v == Blacklight::Engine.config.blacklight.facet_missing_param }
+        f_missing = [] if except.include?(:missing)
 
         f + (f_inclusive || []) + (f_missing || [])
       end
       delegate :any?, to: :values
 
-      # @param [String,#value] a filter to remove from the url
+      # Appease rubocop rules by implementing #each_value
+      def each_value(except: [], &block)
+        values(except: except).each(&block)
+      end
+
+      # @param [String,#value] item a filter to remove from the url
       # @return [Boolean] whether the provided filter is currently applied/selected
       def include?(item)
         if item.respond_to?(:field) && item.field != key
@@ -131,14 +151,22 @@ module Blacklight
         params = search_state.params
 
         if value.is_a?(Array)
-          (params.dig(:f_inclusive, key) || []).to_set == value.to_set
+          (params.dig(inclusive_filters_key, key) || []).to_set == value.to_set
         elsif value == Blacklight::SearchState::FilterField::MISSING
-          (params.dig(:f, "-#{key}") || []).include?(Blacklight::Engine.config.blacklight.facet_missing_param)
+          (params.dig(filters_key, "-#{key}") || []).include?(Blacklight::Engine.config.blacklight.facet_missing_param)
         else
-          (params.dig(:f, key) || []).include?(value)
+          (params.dig(filters_key, key) || []).include?(value)
         end
       end
 
+      def needs_normalization?(value_params)
+        value_params&.is_a?(Hash) && value_params != Blacklight::SearchState::FilterField::MISSING
+      end
+
+      def normalize(value_params)
+        needs_normalization?(value_params) ? value_params.values : value_params
+      end
+
       private
 
       # TODO: this code is duplicated in Blacklight::FacetsHelperBehavior

data/lib/blacklight/search_state.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'blacklight/deprecations/search_state_normalization'
 require 'blacklight/search_state/filter_field'
 
 module Blacklight
@@ -7,6 +8,7 @@ module Blacklight
   # parameters namely: :f, :q, :page, :per_page and, :sort
   class SearchState
     extend Deprecation
+    include Blacklight::Deprecations::SearchStateNormalization
 
     attr_reader :blacklight_config # Must be called blacklight_config, because Blacklight::Facet calls blacklight_config.
     attr_reader :params
@@ -17,18 +19,7 @@ module Blacklight
 
     delegate :facet_configuration_for_field, to: :blacklight_config
 
-    # @param [ActionController::Parameters] params
-    # @param [Blacklight::Config] blacklight_config
-    # @param [ApplicationController] controller used for the routing helpers
-    def initialize(params, blacklight_config, controller = nil)
-      @params = self.class.normalize_params(params)
-      @blacklight_config = blacklight_config
-      @controller = controller
-    end
-
-    def self.normalize_params(untrusted_params = {})
-      params = untrusted_params
-
+    def self.modifiable_params(params)
       if params.respond_to?(:to_unsafe_h)
         # This is the typical (not-ActionView::TestCase) code path.
         params = params.to_unsafe_h
@@ -40,12 +31,55 @@ module Blacklight
       else
         params = params.dup.to_h.with_indifferent_access
       end
+      params
+    end
 
-      # Normalize facet parameters mangled by facebook
-      params[:f] = normalize_facet_params(params[:f]) if facet_params_need_normalization(params[:f])
-      params[:f_inclusive] = normalize_facet_params(params[:f_inclusive]) if facet_params_need_normalization(params[:f_inclusive])
+    # @param [ActionController::Parameters] params
+    # @param [Blacklight::Config] blacklight_config
+    # @param [ApplicationController] controller used for the routing helpers
+    def initialize(params, blacklight_config, controller = nil)
+      @blacklight_config = blacklight_config
+      @controller = controller
+      @params = SearchState.modifiable_params(params)
+      normalize_params! if needs_normalization?
+    end
 
-      params
+    def needs_normalization?
+      return false if params.blank?
+      return true if (params.keys.map(&:to_s) - permitted_fields.map(&:to_s)).present?
+
+      !!filters.detect { |filter| filter.values.detect { |value| filter.needs_normalization?(value) } }
+    end
+
+    def normalize_params!
+      @params = normalize_params
+    end
+
+    def normalize_params
+      return params unless needs_normalization?
+
+      base_params = params.slice(*blacklight_config.search_state_fields)
+      normal_state = blacklight_config.facet_fields.each_value.inject(reset(base_params)) do |working_state, filter_key|
+        f = filter(filter_key)
+        next working_state unless f.any?
+
+        filter_values = f.values(except: [:inclusive_filters]).inject([]) do |memo, filter_value|
+          # flatten arrays that had been mangled into integer-indexed hashes
+          memo.concat([f.normalize(filter_value)].flatten)
+        end
+        filter_values = f.values(except: [:filters, :missing]).inject(filter_values) do |memo, filter_value|
+          memo << f.normalize(filter_value)
+        end
+        filter_values.inject(working_state) do |memo, filter_value|
+          memo.filter(filter_key).add(filter_value)
+        end
+      end
+      normal_state.params
+    end
+
+    def permitted_fields
+      filter_keys = filter_fields.inject(Set.new) { |memo, filter| memo.merge [filter.filters_key, filter.inclusive_filters_key] }
+      blacklight_config.search_state_fields + filter_keys.subtract([nil, '']).to_a
     end
 
     def to_hash
@@ -129,11 +163,7 @@ module Blacklight
     end
 
     def filters
-      @filters ||= blacklight_config.facet_fields.each_value.map do |value|
-        f = filter(value)
-
-        f if f.any?
-      end.compact
+      @filters ||= filter_fields.select(&:any?)
     end
 
     def filter(field_key_or_field)
@@ -248,16 +278,6 @@ module Blacklight
       params[facet_request_keys[:prefix]]
     end
 
-    def self.facet_params_need_normalization(facet_params)
-      facet_params.is_a?(Hash) && facet_params.values.any? { |x| x.is_a?(Hash) }
-    end
-
-    def self.normalize_facet_params(facet_params)
-      facet_params.transform_values do |value|
-        value.is_a?(Hash) ? value.values : value
-      end
-    end
-
     private
 
     def search_field_key
@@ -279,5 +299,9 @@ module Blacklight
     def reset_search_params
       Parameters.sanitize(params).except(:page, :counter)
     end
+
+    def filter_fields
+      blacklight_config.facet_fields.each_value.map { |value| filter(value) }
+    end
   end
 end

data/lib/blacklight/solr/search_builder_behavior.rb

@@ -146,7 +146,9 @@ module Blacklight::Solr
         if filter.config.filter_query_builder
           filter_query, subqueries = filter.config.filter_query_builder.call(self, filter, solr_parameters)
 
-          solr_parameters.append_filter_query(filter_query) if filter_query
+          Array(filter_query).each do |fq|
+            solr_parameters.append_filter_query(fq)
+          end
           solr_parameters.merge!(subqueries) if subqueries
         else
           filter.values.reject(&:blank?).each do |value|

data/lib/blacklight.rb

@@ -7,6 +7,7 @@ require 'jbuilder'
 
 module Blacklight
   autoload :AbstractRepository, 'blacklight/abstract_repository'
+  autoload :Component, 'blacklight/component'
   autoload :Configuration, 'blacklight/configuration'
   autoload :Exceptions,  'blacklight/exceptions'
   autoload :Parameters,  'blacklight/parameters'

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blacklight-frontend",
-  "version": "7.22.1",
+  "version": "7.25.0",
   "description": "[![Build Status](https://travis-ci.com/projectblacklight/blacklight.png?branch=main)](https://travis-ci.com/projectblacklight/blacklight) [![Gem Version](https://badge.fury.io/rb/blacklight.png)](http://badge.fury.io/rb/blacklight) [![Coverage Status](https://coveralls.io/repos/github/projectblacklight/blacklight/badge.svg?branch=main)](https://coveralls.io/github/projectblacklight/blacklight?branch=main)",
   "main": "app/assets/javascripts/blacklight",
   "scripts": {

data/spec/components/blacklight/constraints_component_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe Blacklight::ConstraintsComponent, type: :component do
   end
 
   let(:blacklight_config) do
-    Blacklight::Configuration.new.tap do |config|
+    Blacklight::Configuration.new.configure do |config|
       config.add_facet_field 'some_facet'
     end
   end
@@ -43,6 +43,19 @@ RSpec.describe Blacklight::ConstraintsComponent, type: :component do
   context 'with a facet' do
     let(:query_params) { { f: { some_facet: ['some value'] } } }
 
+    before do
+      controller.blacklight_config.configure do |config|
+        config.add_facet_field :some_facet
+      end
+    end
+
+    # this has to be cleaned up to prevent leaking class configuration
+    after do
+      controller.blacklight_config.configure do |config|
+        config['facet_fields'].delete('some_facet')
+      end
+    end
+
     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

data/spec/components/blacklight/facet_field_list_component_spec.rb

@@ -123,7 +123,12 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
       )
     end
 
-    let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+    let(:blacklight_config) do
+      Blacklight::Configuration.new.configure do |config|
+        config.add_facet_field :field
+      end
+    end
+    let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config) }
     let(:params) { { f_inclusive: { field: %w[a b c] } } }
 
     it 'displays the constraint above the list' do

data/spec/components/blacklight/facet_item_pivot_component_spec.rb

@@ -7,8 +7,14 @@ RSpec.describe Blacklight::FacetItemPivotComponent, type: :component do
     render_inline_to_capybara_node(described_class.new(facet_item: facet_item))
   end
 
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_facet_field :z
+    end
+  end
+
   let(:search_state) do
-    Blacklight::SearchState.new({}, Blacklight::Configuration.new)
+    Blacklight::SearchState.new({}, blacklight_config)
   end
 
   let(:facet_item) do

data/spec/controllers/blacklight/base_spec.rb

@@ -11,7 +11,10 @@ RSpec.describe Blacklight::Base do
     let(:raw_params) { HashWithIndifferentAccess.new a: 1 }
     let(:params) { ActionController::Parameters.new raw_params }
 
-    before { allow(controller).to receive_messages(params: params) }
+    before do
+      controller.blacklight_config.search_state_fields << :a
+      allow(controller).to receive_messages(params: params)
+    end
 
     it "creates a path object" do
       expect(subject).to be_kind_of Blacklight::SearchState

data/spec/helpers/blacklight/facets_helper_behavior_spec.rb

@@ -246,6 +246,10 @@ RSpec.describe Blacklight::FacetsHelperBehavior do
   end
 
   describe "facet_field_in_params?" do
+    before do
+      blacklight_config.add_facet_field "some-field"
+    end
+
     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).to be_facet_field_in_params("some-field")
@@ -254,16 +258,29 @@ RSpec.describe Blacklight::FacetsHelperBehavior do
   end
 
   describe "facet_params" do
+    let(:facet_config) { ["some-field"] }
+    let(:params) { { f: { "some-field" => ["x"] } } }
+
+    before do
+      blacklight_config.add_facet_field *facet_config
+      allow(helper).to receive_messages(params: params)
+    end
+
     it "extracts the facet parameters for a field" do
-      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"] } })
-      expect(helper.facet_params("some-key")).to match_array ["x"]
-      expect(helper.facet_params("some-field")).to match_array ["x"]
+    context "a facet is not keyed by the field name" do
+      let(:facet_config) { ["some-key", { field: "some-field" }] }
+      let(:params) { { f: { "some-key" => ["x"] } } }
+
+      it "uses the blacklight key to extract the right fields" do
+        expect(helper.facet_params("some-key")).to match_array ["x"]
+      end
+
+      it "looks up facet params by configured field or key values" do
+        expect(helper.facet_params("some-field")).to match_array ["x"]
+      end
     end
   end
 

data/spec/helpers/blacklight/url_helper_behavior_spec.rb

@@ -75,6 +75,13 @@ RSpec.describe Blacklight::UrlHelperBehavior do
     let(:query_params) { { q: "query", f: "facets", controller: 'catalog' } }
     let(:bookmarks_query_params) { { controller: 'bookmarks' } }
 
+    before do
+      # this is bad data but the legacy test exercises search fields, not filters
+      blacklight_config.configure do |config|
+        config.search_state_fields << :f
+      end
+    end
+
     it "builds a link tag to catalog using session[:search] for query params" do
       allow(helper).to receive(:current_search_session).and_return double(query_params: query_params)
       tag = helper.link_back_to_catalog

data/spec/lib/blacklight/component_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Component do
+  let(:component_class) { Blacklight::DocumentTitleComponent }
+
+  context "subclassed" do
+    it "returns our Compiler implementation" do
+      expect(component_class.ancestors).to include described_class
+      expect(component_class.compiler).to be_a Blacklight::Component::EngineCompiler
+    end
+  end
+
+  describe Blacklight::Component::EngineCompiler do
+    subject(:compiler) { described_class.new(component_class) }
+
+    let(:original_compiler) { ViewComponent::Compiler.new(component_class) }
+    let(:original_path) { original_compiler.send(:templates).first[:path] }
+    let(:resolved_path) { compiler.templates.first[:path] }
+
+    context "without overrides" do
+      it "links to engine template" do
+        expect(resolved_path).not_to include(".internal_test_app")
+        expect(resolved_path).to eql(original_path)
+      end
+    end
+
+    context "with overrides" do
+      let(:path_match) do
+        Regexp.new(Regexp.escape(File.join(".internal_test_app", component_class.view_component_path)))
+      end
+
+      before do
+        allow(File).to receive(:exist?).and_call_original
+        allow(File).to receive(:exist?).with(path_match).and_return(true)
+      end
+
+      it "links to application template" do
+        expect(resolved_path).to include(".internal_test_app")
+        expect(resolved_path).not_to eql(original_path)
+      end
+    end
+  end
+end

data/spec/lib/blacklight/search_state/filter_field_spec.rb

@@ -6,10 +6,13 @@ RSpec.describe Blacklight::SearchState::FilterField do
   let(:params) { { f: { some_field: %w[1 2], another_field: ['3'] } } }
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.add_facet_field 'some_field'
       config.add_facet_field 'another_field', single: true
+      simple_facet_fields.each { |simple_facet_field| config.add_facet_field simple_facet_field }
+      config.search_state_fields = config.search_state_fields + additional_search_fields
     end
   end
+  let(:simple_facet_fields) { [:some_field] }
+  let(:additional_search_fields) { [] }
   let(:controller) { double }
 
   describe '#add' do
@@ -50,6 +53,8 @@ RSpec.describe Blacklight::SearchState::FilterField do
     end
 
     context 'with a pivot facet-type item' do
+      let(:simple_facet_fields) { [:some_field, :some_other_field] }
+
       it 'includes the pivot facet fqs' do
         filter = search_state.filter('some_field')
         new_state = filter.add(OpenStruct.new(fq: { some_other_field: '5' }, value: '4'))
@@ -200,4 +205,10 @@ RSpec.describe Blacklight::SearchState::FilterField do
       expect(search_state.filter('some_field').include?(OpenStruct.new(value: '1'))).to eq true
     end
   end
+
+  describe '#needs_normalization?' do
+    it 'returns false for Blacklight::SearchState::FilterField::MISSING' do
+      expect(search_state.filter('some_field').needs_normalization?(Blacklight::SearchState::FilterField::MISSING)).to be false
+    end
+  end
 end

data/spec/lib/blacklight/search_state_spec.rb

@@ -9,14 +9,19 @@ RSpec.describe Blacklight::SearchState do
     Blacklight::Configuration.new.configure do |config|
       config.index.title_field = 'title_tsim'
       config.index.display_type_field = 'format'
+      simple_facet_fields.each { |simple_facet_field| config.add_facet_field simple_facet_field }
+      config.search_state_fields = config.search_state_fields + additional_search_fields
     end
   end
 
   let(:parameter_class) { ActionController::Parameters }
   let(:controller) { double }
   let(:params) { parameter_class.new }
+  let(:simple_facet_fields) { [:facet_field_1, :facet_field_2] }
+  let(:additional_search_fields) { [] }
 
   describe '#to_h' do
+    let(:additional_search_fields) { [:a] }
     let(:data) { { a: '1' } }
     let(:params) { parameter_class.new data }
 
@@ -50,6 +55,7 @@ RSpec.describe Blacklight::SearchState do
     end
 
     context 'with facebooks badly mangled query parameters' do
+      let(:simple_facet_fields) { [:field] }
       let(:params) do
         { f: { field: { '0': 'first', '1': 'second' } },
           f_inclusive: { field: { '0': 'first', '1': 'second' } } }
@@ -62,6 +68,7 @@ RSpec.describe Blacklight::SearchState do
     end
 
     context 'deleting item from to_h' do
+      let(:additional_search_fields) { [:q_1] }
       let(:params) { { q: 'foo', q_1: 'bar' } }
 
       it 'does not mutate search_state to mutate search_state.to_h' do
@@ -74,6 +81,7 @@ RSpec.describe Blacklight::SearchState do
     end
 
     context 'deleting deep item from to_h' do
+      let(:additional_search_fields) { [:foo] }
       let(:params) { { foo: { bar: [] } } }
 
       it 'does not mutate search_state to deep mutate search_state.to_h' do
@@ -87,6 +95,7 @@ RSpec.describe Blacklight::SearchState do
   end
 
   describe 'interface compatibility with params' do
+    let(:simple_facet_fields) { [:ff] }
     let(:params) { parameter_class.new f: { ff: ['xyz'] } }
 
     it 'implements param methods' do
@@ -107,6 +116,7 @@ RSpec.describe Blacklight::SearchState do
   end
 
   describe '#filter_params' do
+    let(:simple_facet_fields) { [:ff] }
     let(:params) { parameter_class.new f: { ff: ['xyz'] } }
 
     it 'returns the query param' do
@@ -128,6 +138,7 @@ RSpec.describe Blacklight::SearchState do
     end
 
     context 'with a facet param' do
+      let(:simple_facet_fields) { [:ff] }
       let(:params) { parameter_class.new f: { ff: ['xyz'] } }
 
       it 'is true' do
@@ -137,6 +148,7 @@ RSpec.describe Blacklight::SearchState do
   end
 
   describe "params_for_search" do
+    let(:additional_search_fields) { [:default] }
     let(:params) { parameter_class.new 'default' => 'params' }
 
     it "takes original params" do
@@ -198,6 +210,7 @@ RSpec.describe Blacklight::SearchState do
     end
 
     context "with a block" do
+      let(:additional_search_fields) { [:a, :b, :c, :d] }
       let(:params) { parameter_class.new a: 1, b: 2 }
 
       it "evalutes the block and allow it to add or remove keys" do
@@ -356,6 +369,7 @@ RSpec.describe Blacklight::SearchState do
   end
 
   describe "#remove_facet_params" do
+    let(:simple_facet_fields) { [:some_field, :another_field] }
     let(:params) { parameter_class.new 'f' => facet_params }
     let(:facet_params) { {} }
 
@@ -382,9 +396,7 @@ RSpec.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")
-        )
+        blacklight_config.facet_fields['some_field'].merge!(single: true, field: "a_solr_field", key: 'some_key')
       end
 
       let(:facet_params) { { 'some_key' => %w[some_value another_value] } }
@@ -415,6 +427,8 @@ RSpec.describe Blacklight::SearchState do
   end
 
   describe '#reset' do
+    let(:additional_search_fields) { [:a] }
+
     it 'returns a search state with the given parameters' do
       new_state = search_state.reset('a' => 1)
 

data/spec/models/blacklight/configuration_spec.rb

@@ -552,7 +552,7 @@ RSpec.describe "Blacklight::Configuration", api: true do
     end
 
     it "takes ShowField argument" do
-      config.add_sms_field("title_tsim", Blacklight::Configuration::SmsField.new(field: "title_display", label: "Title"))
+      config.add_sms_field("title_tsim", Blacklight::Configuration::DisplayField.new(field: "title_display", label: "Title"))
 
       expect(config.sms_fields["title_tsim"]).not_to be_nil
       expect(config.sms_fields["title_tsim"].label).to eq "Title"
@@ -598,7 +598,7 @@ RSpec.describe "Blacklight::Configuration", api: true do
     end
 
     it "takes ShowField argument" do
-      config.add_email_field("title_tsim", Blacklight::Configuration::EmailField.new(field: "title_display", label: "Title"))
+      config.add_email_field("title_tsim", Blacklight::Configuration::DisplayField.new(field: "title_display", label: "Title"))
 
       expect(config.email_fields["title_tsim"]).not_to be_nil
       expect(config.email_fields["title_tsim"].label).to eq "Title"

data/spec/models/blacklight/solr/search_builder_spec.rb

@@ -273,6 +273,21 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, api: true do
       end
     end
 
+    context 'with a facet with a custom filter query builder that returns multiple values' do
+      let(:user_params) { { f: { some: ['value'] } }.with_indifferent_access }
+
+      before do
+        blacklight_config.add_facet_field 'some', filter_query_builder: (lambda do |*_args|
+          [['some:filter', 'another:filter'], { qq1: 'abc' }]
+        end)
+      end
+
+      it "has proper solr parameters" do
+        expect(subject[:fq]).to include('some:filter', 'another:filter')
+        expect(subject[:qq1]).to include('abc')
+      end
+    end
+
     describe 'with a json facet' do
       let(:user_params) { { f: { json_facet: ['value'] } }.with_indifferent_access }