blacklight 7.32.0 → 8.0.0.beta1

data/spec/features/search_results_spec.rb

@@ -58,36 +58,3 @@ RSpec.describe "Search Results" do
     expect(page).to have_xpath("//a[contains(@href, 77826928)]")
   end
 end
-
-def search_for q
-  visit root_path
-  fill_in "q", with: q
-  click_button 'search'
-end
-
-def position_in_result_page(page, id)
-  i = -1
-  page.all(".index_title a").each_with_index do |link, idx|
-    i = (idx + 1) if link['href'] =~ Regexp.new(Regexp.escape(id) + "$")
-  end
-  i.to_i
-end
-
-def number_of_results_for_query(query)
-  visit root_path
-  fill_in "q", with: query
-  click_button "search"
-  get_number_of_results_from_page(page)
-end
-
-def number_of_results_from_page(page)
-  tmp_value = Capybara.ignore_hidden_elements
-  Capybara.ignore_hidden_elements = false
-  val = begin
-          page.find("meta[name=totalResults]")['content'].to_i
-        rescue StandardError
-          0
-        end
-  Capybara.ignore_hidden_elements = tmp_value
-  val
-end

data/spec/helpers/blacklight/configuration_helper_behavior_spec.rb

@@ -8,14 +8,6 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
     allow(helper).to receive_messages(blacklight_config: blacklight_config)
   end
 
-  describe "#index_fields" do
-    it "passes through the configuration" do
-      allow(Deprecation).to receive(:warn)
-      allow(blacklight_config).to receive_messages(index_fields: config_value)
-      expect(helper.index_fields).to eq config_value
-    end
-  end
-
   describe "#active_sort_fields" do
     it "restricts the configured sort fields to only those that should be displayed" do
       allow(blacklight_config).to receive_messages(sort_fields: { a: double(if: false, unless: false), b: double(if: true, unless: true) })
@@ -23,17 +15,9 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
     end
   end
 
-  describe "#document_show_fields" do
-    it "passes through the configuration" do
-      allow(Deprecation).to receive(:warn)
-      allow(blacklight_config).to receive_messages(show_fields: config_value)
-      expect(helper.document_show_fields).to eq config_value
-    end
-  end
-
   describe "#default_document_index_view_type" do
     it "uses the first view with default set to true" do
-      blacklight_config.view.a({})
+      blacklight_config.view.a
       blacklight_config.view.b(default: true)
       expect(helper.default_document_index_view_type).to eq :b
     end
@@ -71,62 +55,6 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
     end
   end
 
-  describe "#has_alternative_views?" do
-    subject { helper.has_alternative_views? }
-
-    before do
-      blacklight_config.view.clear
-    end
-
-    describe "with a single view defined" do
-      it { is_expected.to be false }
-    end
-
-    describe "with multiple views defined" do
-      before do
-        blacklight_config.view.abc
-        blacklight_config.view.xyz
-      end
-
-      it { is_expected.to be true }
-    end
-  end
-
-  describe "#spell_check_max" do
-    it "passes through the configuration" do
-      allow(blacklight_config).to receive_messages(spell_max: config_value)
-      expect(helper.spell_check_max).to eq config_value
-    end
-  end
-
-  describe "#document_show_link_field" do
-    let(:document) { SolrDocument.new id: 123, a: 1, b: 2, c: 3 }
-
-    before do
-      allow(Deprecation).to receive(:warn)
-    end
-
-    it "allows single values" do
-      blacklight_config.index.title_field = :a
-      f = helper.document_show_link_field document
-      expect(f).to eq :a
-    end
-
-    it "retrieves the first field with data" do
-      blacklight_config.index.title_field = [:zzz, :b]
-      f = helper.document_show_link_field document
-      expect(f).to eq :b
-    end
-  end
-
-  describe "#view_label" do
-    it "looks up the label to display for the view" do
-      allow(blacklight_config).to receive(:view).and_return("my_view" => double(display_label: "some label"))
-
-      helper.view_label "my_view"
-    end
-  end
-
   describe "#field_label" do
     it "looks up the label as an i18n string" do
       expect(helper).to receive(:t).with(:some_key, default: []).and_return "my label"
@@ -148,32 +76,6 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
     end
   end
 
-  describe "#default_per_page" do
-    before do
-      expect(Deprecation).to receive(:warn)
-    end
-
-    context "when default_per_page is configured" do
-      before do
-        blacklight_config.default_per_page = 42
-      end
-
-      it "is the configured value" do
-        expect(helper.default_per_page).to eq 42
-      end
-    end
-
-    context "when default_per_page is not configured" do
-      before do
-        blacklight_config.per_page = [11, 22]
-      end
-
-      it "is the first per-page value if a default isn't set" do
-        expect(helper.default_per_page).to eq 11
-      end
-    end
-  end
-
   describe "#default_sort_field" do
     it "is the configured default field" do
       allow(helper).to receive_messages(blacklight_config: double(sort_fields: { a: double(default: nil), b: double(key: 'b', default: true) }))
@@ -203,11 +105,6 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
   describe "#should_render_field?" do
     let(:field_config) { double('field config', if: true, unless: false) }
 
-    before do
-      allow(Deprecation).to receive(:warn)
-      allow(helper).to receive_messages(document_has_value?: true)
-    end
-
     it "is true" do
       expect(helper.should_render_field?(field_config)).to be true
     end
@@ -223,39 +120,6 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
     end
   end
 
-  describe "#search_field_options_for_select" do
-    before do
-      @config = Blacklight::Configuration.new do |config|
-        config.default_solr_params = { qt: 'search' }
-
-        config.add_search_field 'all_fields', label: 'All Fields'
-        config.add_search_field 'title', qt: 'title_search'
-        config.add_search_field 'author', qt: 'author_search'
-        config.add_search_field 'subject', qt: 'subject_search'
-        config.add_search_field 'no_display', qt: 'something', include_in_simple_select: false
-      end
-
-      allow(helper).to receive_messages(blacklight_config: @config)
-    end
-
-    it "returns proper options_for_select arguments" do
-      select_arguments = helper.search_field_options_for_select
-
-      select_arguments.each do |(label, key)|
-        config_hash = @config.search_fields[key]
-
-        expect(label).to eq config_hash.label
-        expect(key).to eq config_hash.key
-      end
-    end
-
-    it "does not include fields in select if :display_in_simple_search=>false" do
-      select_arguments = helper.search_field_options_for_select
-
-      expect(select_arguments).not_to include(["No Display", "no_display"])
-    end
-  end
-
   context 'labels' do
     let(:field_config) { { 'my-key' => double('field', display_label: 'My Field') } }
 
@@ -275,7 +139,7 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
       end
 
       it 'handles a missing field' do
-        expect(helper.label_for_search_field(nil)).to eq nil
+        expect(helper.label_for_search_field(nil)).to be_nil
       end
     end
 

data/spec/helpers/blacklight/facets_helper_behavior_spec.rb

@@ -3,397 +3,10 @@
 RSpec.describe Blacklight::FacetsHelperBehavior do
   let(:blacklight_config) { Blacklight::Configuration.new }
 
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
   before do
     allow(helper).to receive(:blacklight_config).and_return blacklight_config
   end
 
-  describe "has_facet_values?" do
-    let(:empty) { double(items: [], name: 'empty') }
-    let(:response) { instance_double(Blacklight::Solr::Response) }
-
-    it "is true if there are any facets to display" do
-      a = double(items: [1, 2], name: 'a')
-      b = double(items: %w[b c], name: 'b')
-      fields = [a, b, empty]
-      expect(helper.has_facet_values?(fields, response)).to be true
-    end
-
-    it "is false if all facets are empty" do
-      expect(helper.has_facet_values?([empty], response)).to be false
-    end
-
-    describe "different config" do
-      let(:blacklight_config) { Blacklight::Configuration.new { |config| config.add_facet_field 'basic_field', if: false } }
-
-      it "is false if no facets are displayable" do
-        a = double(items: [1, 2], name: 'basic_field')
-        expect(helper.has_facet_values?([a], response)).to be false
-      end
-    end
-  end
-
-  describe "should_render_facet?" do
-    let(:blacklight_config) do
-      Blacklight::Configuration.new do |config|
-        config.add_facet_field 'basic_field'
-        config.add_facet_field 'no_show', show: false
-        config.add_facet_field 'helper_show', show: :my_custom_check
-        config.add_facet_field 'helper_with_an_arg_show', show: :my_custom_check_with_an_arg
-        config.add_facet_field 'lambda_show',    show: ->(_context, _config, _field) { true }
-        config.add_facet_field 'lambda_no_show', show: ->(_context, _config, _field) { false }
-      end
-    end
-
-    it "renders facets with items" do
-      a = double(items: [1, 2], name: 'basic_field')
-      expect(helper.should_render_facet?(a)).to be true
-    end
-
-    it "does not render facets without items" do
-      empty = double(items: [], name: 'basic_field')
-      expect(helper.should_render_facet?(empty)).to be false
-    end
-
-    it "does not render facets where show is set to false" do
-      a = double(items: [1, 2], name: 'no_show')
-      expect(helper.should_render_facet?(a)).to be false
-    end
-
-    it "calls a helper to determine if it should render a field" do
-      allow(controller).to receive_messages(my_custom_check: true)
-      a = double(items: [1, 2], name: 'helper_show')
-      expect(helper.should_render_facet?(a)).to be true
-    end
-
-    it "calls a helper to determine if it should render a field" do
-      a = double(items: [1, 2], name: 'helper_with_an_arg_show')
-      allow(controller).to receive(:my_custom_check_with_an_arg).with(blacklight_config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
-      expect(helper.should_render_facet?(a)).to be true
-    end
-
-    it "evaluates a Proc to determine if it should render a field" do
-      a = double(items: [1, 2], name: 'lambda_show')
-      expect(helper.should_render_facet?(a)).to be true
-      a = double(items: [1, 2], name: 'lambda_no_show')
-      expect(helper.should_render_facet?(a)).to be false
-    end
-  end
-
-  describe "should_collapse_facet?" do
-    let(:blacklight_config) do
-      Blacklight::Configuration.new do |config|
-        config.add_facet_field 'basic_field'
-        config.add_facet_field 'no_collapse', collapse: false
-      end
-    end
-
-    it "is collapsed by default" do
-      expect(helper.should_collapse_facet?(blacklight_config.facet_fields['basic_field'])).to be true
-    end
-
-    it "does not be collapsed if the configuration says so" do
-      expect(helper.should_collapse_facet?(blacklight_config.facet_fields['no_collapse'])).to be false
-    end
-
-    it "does not be collapsed if it is in the params" do
-      params[:f] = ActiveSupport::HashWithIndifferentAccess.new(basic_field: [1], no_collapse: [2])
-      expect(helper.should_collapse_facet?(blacklight_config.facet_fields['basic_field'])).to be false
-      expect(helper.should_collapse_facet?(blacklight_config.facet_fields['no_collapse'])).to be false
-    end
-  end
-
-  describe "facet_by_field_name" do
-    around { |test| Deprecation.silence(Blacklight::Facet) { test.call } }
-
-    it "retrieves the facet from the response given a string" do
-      facet_config = double(query: nil, field: 'b', key: 'a')
-      facet_field = double
-      allow(helper).to receive(:facet_configuration_for_field).with('b').and_return(facet_config)
-      response = instance_double(Blacklight::Solr::Response, aggregations: { 'b' => facet_field })
-
-      expect(helper.facet_by_field_name('b', response)).to eq facet_field
-    end
-  end
-
-  describe "render_facet_partials" do
-    let(:a) { double(items: [1, 2]) }
-    let(:b) { double(items: %w[b c]) }
-    let(:response) { instance_double(Blacklight::Solr::Response) }
-
-    it "tries to render all provided facets" do
-      empty = double(items: [])
-      fields = [a, b, empty]
-      expect(helper).to receive(:render_facet_limit).with(a, {})
-      expect(helper).to receive(:render_facet_limit).with(b, {})
-      expect(helper).to receive(:render_facet_limit).with(empty, {})
-      helper.render_facet_partials fields, response: response
-    end
-
-    it "defaults to the configured facets" do
-      allow(Deprecation).to receive(:warn)
-      expect(helper).to receive(:facet_field_names) { [a, b] }
-      expect(helper).to receive(:render_facet_limit).with(a, {})
-      expect(helper).to receive(:render_facet_limit).with(b, {})
-      helper.render_facet_partials
-    end
-  end
-
-  describe "render_facet_limit" do
-    let(:blacklight_config) do
-      Blacklight::Configuration.new do |config|
-        config.add_facet_field 'basic_field'
-        config.add_facet_field 'component_field', component: true
-        config.add_facet_field 'non_rendering_component_field', component: true, if: false
-        config.add_facet_field 'pivot_facet_field', pivot: %w[a b]
-        config.add_facet_field 'my_pivot_facet_field_with_custom_partial', partial: 'custom_facet_partial', pivot: %w[a b]
-        config.add_facet_field 'my_facet_field_with_custom_partial', partial: 'custom_facet_partial'
-      end
-    end
-    let(:mock_custom_facet) { double(name: 'my_facet_field_with_custom_partial', items: [1, 2, 3]) }
-
-    it "sets basic local variables" do
-      mock_facet = double(name: 'basic_field', items: [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit',
-                                                             locals: {
-                                                               field_name: 'basic_field',
-                                                               facet_field: helper.blacklight_config.facet_fields['basic_field'],
-                                                               display_facet: mock_facet
-                                                             }))
-      helper.render_facet_limit(mock_facet)
-    end
-
-    it "renders a facet _not_ declared in the configuration" do
-      mock_facet = double(name: 'asdf', items: [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit'))
-      helper.render_facet_limit(mock_facet)
-    end
-
-    it "gets the partial name from the configuration" do
-      expect(helper).to receive(:render).with(hash_including(partial: 'custom_facet_partial'))
-      helper.render_facet_limit(mock_custom_facet)
-    end
-
-    it "uses a partial layout for rendering the facet frame" do
-      expect(helper).to receive(:render).with(hash_including(layout: 'facet_layout'))
-      helper.render_facet_limit(mock_custom_facet)
-    end
-
-    it "allows the caller to opt-out of facet layouts" do
-      expect(helper).to receive(:render).with(hash_including(layout: nil))
-      helper.render_facet_limit(mock_custom_facet, layout: nil)
-    end
-
-    it "renders the facet_pivot partial for pivot facets" do
-      mock_facet = double(name: 'pivot_facet_field', items: [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(partial: 'facet_pivot'))
-      helper.render_facet_limit(mock_facet)
-    end
-
-    it "lets you override the rendered partial for pivot facets" do
-      mock_facet = double(name: 'my_pivot_facet_field_with_custom_partial', items: [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(partial: 'custom_facet_partial'))
-      helper.render_facet_limit(mock_facet)
-    end
-
-    it "lets you override the rendered partial for pivot facets" do
-      mock_facet = double(name: 'component_field')
-      expect(helper).to receive(:render).with(an_instance_of(Blacklight::FacetComponent))
-      helper.render_facet_limit(mock_facet)
-    end
-
-    it "lets you override the rendered partial for pivot facets" do
-      mock_facet = double(name: 'non_rendering_component_field')
-      expect(helper.render_facet_limit(mock_facet)).to be_blank
-    end
-  end
-
-  describe "render_facet_limit_list" do
-    subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
-
-    let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
-    let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
-    let(:paginator) { Blacklight::Solr::FacetPaginator.new([f1, f2], limit: 10) }
-
-    before do
-      allow(helper).to receive(:search_action_path) do |*args|
-        search_catalog_path *args
-      end
-    end
-
-    it "draws a list of elements" do
-      expect(subject).to have_selector 'li', count: 2
-      expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
-      expect(subject).to have_selector 'li:nth-child(2) a.facet-select', text: 'Musical Score'
-    end
-
-    context "when one of the facet items is rendered as nil" do
-      # An app may override render_facet_item to filter out some undesired facet items by returning nil.
-      before do
-        allow(helper.method(:render_facet_item)).to receive(:owner).and_return(self.class)
-        # allow_any_instance_of(Blacklight::FacetItemComponent).to receive(:overridden_helper_methods?).and_return(true)
-        allow(helper).to receive(:render_facet_item).and_return('<a class="facet-select">Book</a>'.html_safe, nil)
-      end
-
-      around { |test| Deprecation.silence(Blacklight::FacetItemComponent) { test.call } }
-
-      it "draws a list of elements" do
-        expect(subject).to have_selector 'li', count: 1
-        expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
-      end
-    end
-  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")
-      expect(helper.facet_field_in_params?("other-field")).not_to be true
-    end
-  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
-      expect(helper.facet_params("some-field")).to match_array ["x"]
-    end
-
-    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
-
-  describe "facet_field_in_params?" do
-    let(:search_state) { double }
-
-    before do
-      allow(helper).to receive_messages(search_state: search_state)
-    end
-
-    it "checks if any value is selected for a given facet" do
-      allow(search_state).to receive(:has_facet?).with(having_attributes(key: 'some-facet')).and_return(true)
-      expect(helper.facet_field_in_params?("some-facet")).to eq true
-    end
-
-    it "is false if no value for facet is selected" do
-      allow(search_state).to receive(:has_facet?).with(having_attributes(key: 'some-facet')).and_return(false)
-      expect(helper.facet_field_in_params?("some-facet")).to eq false
-    end
-  end
-
-  describe "facet_in_params?" do
-    let(:search_state) { double }
-
-    before do
-      allow(helper).to receive_messages(search_state: search_state)
-      allow(search_state).to receive(:has_facet?).with(having_attributes(key: 'some-facet'), value: 'x').and_return(true)
-      allow(search_state).to receive(:has_facet?).with(having_attributes(key: 'some-facet'), value: 'y').and_return(false)
-    end
-
-    it "checks if a particular value is set in the facet params" do
-      expect(helper.facet_in_params?("some-facet", "x")).to eq true
-      expect(helper.facet_in_params?("some-facet", "y")).to eq false
-    end
-  end
-
-  describe "render_facet_value" do
-    let(:item) { double(value: 'A', hits: 10) }
-    let(:search_state) { double(has_facet?: false, add_facet_params_and_redirect: { controller: 'catalog' }) }
-
-    before do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(Blacklight::Configuration::FacetField.new(key: 'simple_field', query: nil, date: nil, helper_method: nil, single: false, url_method: nil, item_presenter: nil))
-      allow(helper).to receive(:facet_display_value).and_return('Z')
-      allow(helper).to receive(:search_state).and_return(search_state)
-      allow(helper).to receive(:search_action_path) do |*args|
-        search_catalog_path *args
-      end
-    end
-
-    describe "simple case" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet-select" rel="nofollow" href="/catalog">Z</a></span><span class="facet-count">10</span>' }
-
-      it "uses facet_display_value" do
-        result = helper.render_facet_value('simple_field', item)
-        expect(result).to be_equivalent_to(expected_html).respecting_element_order
-      end
-    end
-
-    describe "when :url_method is set" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet-select" rel="nofollow" href="/blabla">Z</a></span><span class="facet-count">10</span>' }
-
-      it "uses that method" do
-        allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(Blacklight::Configuration::FacetField.new(key: 'simple_field', query: nil, date: nil, helper_method: nil, single: false, url_method: :test_method, item_presenter: nil))
-        allow(helper).to receive(:test_method).with('simple_field', item).and_return('/blabla')
-        result = helper.render_facet_value('simple_field', item)
-        expect(result).to be_equivalent_to(expected_html).respecting_element_order
-      end
-    end
-
-    describe "when :suppress_link is set" do
-      let(:expected_html) { '<span class="facet-label">Z</span><span class="facet-count">10</span>' }
-
-      it "suppresses the link" do
-        result = helper.render_facet_value('simple_field', item, suppress_link: true)
-        expect(result).to be_equivalent_to(expected_html).respecting_element_order
-      end
-    end
-  end
-
-  describe "#facet_display_value" do
-    it "justs be the facet value for an ordinary facet" do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, url_method: nil, item_presenter: nil))
-      expect(helper.facet_display_value('simple_field', 'asdf')).to eq 'asdf'
-    end
-
-    it "allows you to pass in a :helper_method argument to the configuration" do
-      allow(helper).to receive(:facet_configuration_for_field).with('helper_field').and_return(double(query: nil, date: nil, url_method: nil, helper_method: :my_facet_value_renderer, item_presenter: nil))
-      allow(helper).to receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
-      expect(helper.facet_display_value('helper_field', 'qwerty')).to eq 'abc'
-    end
-
-    it "extracts the configuration label for a query facet" do
-      allow(helper).to receive(:facet_configuration_for_field).with('query_facet').and_return(double(query: { 'query_key' => { label: 'XYZ' } }, date: nil, helper_method: nil, url_method: nil, item_presenter: nil))
-      expect(helper.facet_display_value('query_facet', 'query_key')).to eq 'XYZ'
-    end
-
-    it "localizes the label for date-type facets" do
-      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => true, :query => nil, :helper_method => nil, :url_method => nil, :item_presenter => nil))
-      expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq 'Sun, 01 Jan 2012 00:00:00 +0000'
-    end
-
-    it "localizes the label for date-type facets with the supplied localization options" do
-      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { format: :short }, :query => nil, :helper_method => nil, :url_method => nil, :item_presenter => nil))
-      expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq '01 Jan 00:00'
-    end
-  end
-
-  describe "#facet_field_id" do
-    it "is the parameterized version of the facet field" do
-      expect(helper.facet_field_id(double(key: 'some field'))).to eq "facet-some-field"
-    end
-  end
-
   describe '#facet_field_presenter' do
     let(:facet_config) { Blacklight::Configuration::FacetField.new(key: 'x').normalize! }
     let(:display_facet) { double }

data/spec/helpers/blacklight/icon_helper_behavior_spec.rb

@@ -11,5 +11,13 @@ RSpec.describe Blacklight::IconHelperBehavior do
     it 'adds classes to the wrappering element' do
       expect(icon).to have_css '.custom-class svg'
     end
+
+    context 'with backwards compatible arguments' do
+      subject(:icon) { helper.blacklight_icon(:search, aria_hidden: true, label: 'blah') }
+
+      it 'adds aria attributes' do
+        expect(icon).to have_css '[aria-hidden="true"][aria-label="blah"]'
+      end
+    end
   end
 end

data/spec/helpers/blacklight/render_partials_helper_behavior_spec.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 RSpec.describe Blacklight::RenderPartialsHelperBehavior do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
   describe "#type_field_to_partial_name" do
     subject { helper.send(:type_field_to_partial_name, document, value) }
 
@@ -58,7 +56,7 @@ RSpec.describe Blacklight::RenderPartialsHelperBehavior do
       let(:document) { SolrDocument.new }
 
       it "is the default value" do
-        expect(helper.document_partial_name(document)).to eq 'default'
+        expect(helper.send(:document_partial_name, document)).to eq 'default'
       end
     end
 
@@ -70,11 +68,11 @@ RSpec.describe Blacklight::RenderPartialsHelperBehavior do
       end
 
       it "uses the value in the configured display type field" do
-        expect(helper.document_partial_name(document)).to eq 'xyz'
+        expect(helper.send(:document_partial_name, document)).to eq 'xyz'
       end
 
       it "uses the value in the configured display type field if the action-specific field is empty" do
-        expect(helper.document_partial_name(document, :some_action)).to eq 'xyz'
+        expect(helper.send(:document_partial_name, document, :some_action)).to eq 'xyz'
       end
     end
 
@@ -87,8 +85,8 @@ RSpec.describe Blacklight::RenderPartialsHelperBehavior do
       end
 
       it "uses the value in the action-specific fields" do
-        expect(helper.document_partial_name(document, :media)).to eq 'xyz'
-        expect(helper.document_partial_name(document, :metadata)).to eq 'abc'
+        expect(helper.send(:document_partial_name, document, :media)).to eq 'xyz'
+        expect(helper.send(:document_partial_name, document, :metadata)).to eq 'abc'
       end
     end
   end