blacklight 7.5.1 → 7.9.0

data/spec/components/blacklight/facet_item_component_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::FacetItemComponent, type: :component do
+  subject(:render) do
+    render_inline(described_class.new(facet_item: facet_item))
+  end
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:facet_item) do
+    instance_double(
+      Blacklight::FacetItemPresenter,
+      facet_config: Blacklight::Configuration::FacetField.new,
+      label: 'x',
+      hits: 10,
+      href: '/catalog?f=x',
+      selected?: false
+    )
+  end
+
+  it 'links to the facet and shows the number of hits' do
+    expect(rendered).to have_selector 'li'
+    expect(rendered).to have_link 'x', href: '/catalog?f=x'
+    expect(rendered).to have_selector '.facet-count', text: '10'
+  end
+
+  context 'with a selected facet' do
+    let(:facet_item) do
+      instance_double(
+        Blacklight::FacetItemPresenter,
+        facet_config: Blacklight::Configuration::FacetField.new,
+        label: 'x',
+        hits: 10,
+        href: '/catalog',
+        selected?: true
+      )
+    end
+
+    it 'links to the facet and shows the number of hits' do
+      expect(rendered).to have_selector 'li'
+      expect(rendered).to have_selector '.selected', text: 'x'
+      expect(rendered).to have_link '[remove]', href: '/catalog'
+      expect(rendered).to have_selector '.selected.facet-count', text: '10'
+    end
+  end
+end

data/spec/components/blacklight/facet_item_pivot_component_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::FacetItemPivotComponent, type: :component do
+  subject(:render) do
+    render_inline(described_class.new(facet_item: facet_item))
+  end
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:search_state) do
+    Blacklight::SearchState.new({}, Blacklight::Configuration.new)
+  end
+
+  let(:facet_item) do
+    instance_double(
+      Blacklight::FacetItemPresenter,
+      facet_config: Blacklight::Configuration::FacetField.new(key: 'z'),
+      facet_field: 'z',
+      label: 'x',
+      hits: 10,
+      href: '/catalog?f[z]=x',
+      selected?: false,
+      search_state: search_state,
+      items: [OpenStruct.new(value: 'x:1', hits: 5)]
+    )
+  end
+
+  it 'links to the facet and shows the number of hits' do
+    expect(rendered).to have_selector 'li'
+    expect(rendered).to have_link 'x', href: '/catalog?f[z]=x'
+    expect(rendered).to have_selector '.facet-count', text: '10'
+  end
+
+  it 'has the facet hierarchy' do
+    puts render
+    expect(rendered).to have_selector 'li ul.pivot-facet'
+    expect(rendered).to have_link 'x:1', href: /f%5Bz%5D%5B%5D=x%3A1/
+  end
+
+  context 'with a selected facet' do
+    let(:facet_item) do
+      instance_double(
+        Blacklight::FacetItemPresenter,
+        facet_config: Blacklight::Configuration::FacetField.new,
+        facet_field: 'z',
+        label: 'x',
+        hits: 10,
+        href: '/catalog',
+        selected?: true,
+        search_state: search_state,
+        items: []
+      )
+    end
+
+    it 'links to the facet and shows the number of hits' do
+      expect(rendered).to have_selector 'li'
+      expect(rendered).to have_selector '.selected', text: 'x'
+      expect(rendered).to have_link '[remove]', href: '/catalog'
+      expect(rendered).to have_selector '.selected.facet-count', text: '10'
+    end
+  end
+end

data/spec/features/facets_spec.rb

@@ -67,6 +67,26 @@ RSpec.describe "Facets" do
     expect(page).to have_css('#facet-format', visible: true) # assert that it didn't re-collapse
   end
 
+  it 'is able to expand pivot facets when javascript is enabled', js: true do
+    visit root_path
+
+    within('#facets .facets-header') do
+      page.find('button.navbar-toggler').click
+    end
+
+    page.find('h3.facet-field-heading button', text: 'Pivot Field').click
+
+    within '#facet-example_pivot_field' do
+      expect(page).to have_css('.facet-leaf-node', text: 'Book 30')
+      expect(page).not_to have_css('.facet-select', text: 'Tibetan')
+      page.find('.facet-toggle-handle').click
+      click_link 'Tibetan'
+    end
+
+    expect(page).to have_css('.constraint-value', text: 'Format Book')
+    expect(page).to have_css('.constraint-value', text: 'Language Tibetan')
+  end
+
   describe 'heading button focus with Firefox' do
     before do
       Capybara.current_driver = :selenium_headless
@@ -88,7 +108,7 @@ RSpec.describe "Facets" do
     it 'has default more link with sr-only text' do
       visit root_path
       within '#facet-language_ssim' do
-        expect(page).to have_css 'li.more_facets', text: 'more Language'
+        expect(page).to have_css 'div.more_facets', text: 'more Language'
       end
     end
   end

data/spec/helpers/blacklight/configuration_helper_behavior_spec.rb

@@ -274,6 +274,9 @@ RSpec.describe Blacklight::ConfigurationHelperBehavior do
       it 'handles a missing key' do
         expect(helper.label_for_search_field('not-found')).to eq 'Not Found'
       end
+      it 'handles a missing field' do
+        expect(helper.label_for_search_field(nil)).to eq nil
+      end
     end
 
     describe '#sort_field_label' do

data/spec/helpers/blacklight/facets_helper_behavior_spec.rb

@@ -214,7 +214,11 @@ RSpec.describe Blacklight::FacetsHelperBehavior do
 
     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 { allow(helper).to receive(:render_facet_item).and_return('<a class="facet-select">Book</a>'.html_safe, 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
 
       it "draws a list of elements" do
         expect(subject).to have_selector 'li', count: 1
@@ -246,36 +250,44 @@ RSpec.describe Blacklight::FacetsHelperBehavior do
   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(helper).to receive_messages(facet_params: ["x"])
+      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(helper).to receive_messages(facet_params: nil)
+      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
-      allow(helper).to receive_messages(facet_params: ["x"])
       expect(helper.facet_in_params?("some-facet", "x")).to eq true
       expect(helper.facet_in_params?("some-facet", "y")).to eq false
     end
-
-    it "is false if no value for facet is selected" do
-      allow(helper).to receive_messages(facet_params: nil)
-      expect(helper.facet_in_params?("some-facet", "x")).to eq false
-    end
   end
 
   describe "render_facet_value" do
     let(:item) { double(value: 'A', hits: 10) }
-    let(:search_state) { double(add_facet_params_and_redirect: { controller: 'catalog' }) }
+    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(double(query: nil, date: nil, helper_method: nil, single: false, url_method: nil))
+      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))
       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|
@@ -296,7 +308,7 @@ RSpec.describe Blacklight::FacetsHelperBehavior do
       let(:expected_html) { '<span class="facet-label"><a class="facet-select" 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(double(query: nil, date: nil, helper_method: nil, single: false, url_method: :test_method))
+        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))
         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

data/spec/helpers/blacklight/render_constraints_helper_behavior_spec.rb

@@ -13,6 +13,9 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
     allow(helper).to receive(:search_action_path) do |*args|
       search_catalog_path *args
     end
+
+    allow(helper).to receive(:blacklight_config).and_return(config)
+    allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
   end
 
   describe '#render_constraints_query' do
@@ -22,24 +25,7 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
     let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }) }
 
     it "has a link relative to the current url" do
-      expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
-    end
-
-    context 'with an ordinary hash' do
-      let(:params) { { q: 'foobar', f: { type: 'journal' } } }
-
-      it "has a link relative to the current url" do
-        expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
-      end
-    end
-
-    context "with a route_set" do
-      let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }, route_set: my_engine) }
-
-      it "accepts an optional route set" do
-        expect(my_engine).to receive(:url_for).and_return('/?f%5Btype%5D=journal')
-        expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
-      end
+      expect(subject).to have_link 'Remove constraint', href: '/catalog?f%5Btype%5D=journal'
     end
   end
 
@@ -73,11 +59,6 @@ RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
 
     let(:params) { ActionController::Parameters.new f: { 'type' => [''] } }
 
-    before do
-      allow(helper).to receive(:blacklight_config).and_return(config)
-      allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
-    end
-
     it "renders nothing for empty facet limit param" do
       expect(subject).to be_blank
     end

data/spec/helpers/blacklight_helper_spec.rb

@@ -208,6 +208,23 @@ RSpec.describe BlacklightHelper do
     end
   end
 
+  describe '#render_index_field_label' do
+    let(:doc) { SolrDocument.new({}) }
+
+    before do
+      allow(helper).to receive_messages(document_index_view_type: :current_view)
+    end
+
+    it 'accepts an explicit field label' do
+      expect(helper.render_index_field_label(doc, field: 'xyz', label: 'some label')).to eq 'some label:'
+    end
+
+    it 'calculates the appropriate field label for a field' do
+      allow(helper).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
+      expect(helper.render_index_field_label(doc, field: 'xyz')).to eq 'Xyz:'
+    end
+  end
+
   describe "render_grouped_response?" do
     it "checks if the response ivar contains grouped data" do
       assign(:response, instance_double(Blacklight::Solr::Response, grouped?: true))

data/spec/helpers/catalog_helper_spec.rb

@@ -39,13 +39,6 @@ RSpec.describe CatalogHelper do
       expect(html).to be_html_safe
     end
 
-    it "with an empty page of results" do
-      @response = double(limit_value: -1)
-
-      html = page_entries_info(@response)
-      expect(html).to be_blank
-    end
-
     context "when response.entry_name is nil" do
       it "does not raise an error" do
         collection = mock_response total: 10

data/spec/lib/blacklight/search_state_spec.rb

@@ -48,6 +48,56 @@ RSpec.describe Blacklight::SearchState do
     end
   end
 
+  describe 'interface compatibility with params' do
+    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
+
+    it 'implements param methods' do
+      Deprecation.silence(described_class) do
+        expect(search_state.to_unsafe_h).to eq('f' => { 'ff' => ['xyz'] })
+        expect(search_state.fetch(:f)).to eq('ff' => ['xyz'])
+        expect(search_state.select { |k, _v,| k == 'f' }).to eq('f' => { 'ff' => ['xyz'] })
+      end
+    end
+  end
+
+  describe '#query_param' do
+    let(:params) { parameter_class.new q: 'xyz' }
+
+    it 'returns the query param' do
+      expect(search_state.query_param).to eq 'xyz'
+    end
+  end
+
+  describe '#filter_params' do
+    let(:params) { parameter_class.new f: { ff: ['xyz'] } }
+
+    it 'returns the query param' do
+      expect(search_state.filter_params.deep_symbolize_keys).to eq(ff: ['xyz'])
+    end
+  end
+
+  describe '#has_constraints?' do
+    it 'is false' do
+      expect(search_state.has_constraints?).to eq false
+    end
+
+    context 'with a query param' do
+      let(:params) { parameter_class.new q: 'xyz' }
+
+      it 'is true' do
+        expect(search_state.has_constraints?).to eq true
+      end
+    end
+
+    context 'with a facet param' do
+      let(:params) { parameter_class.new f: { ff: ['xyz'] } }
+
+      it 'is true' do
+        expect(search_state.has_constraints?).to eq true
+      end
+    end
+  end
+
   describe "params_for_search" do
     let(:params) { parameter_class.new 'default' => 'params' }
 

data/spec/models/blacklight/configuration_spec.rb

@@ -189,14 +189,18 @@ RSpec.describe "Blacklight::Configuration", api: true do
     it "provides cloned copies of mutable data structures" do
       config.a = { value: 1 }
       config.b = [1, 2, 3]
+      config.c = Blacklight::Configuration::Field.new(key: 'c', value: %w[a b])
 
       config_copy.a[:value] = 2
       config_copy.b << 5
+      config_copy.c.value << 'c'
 
       expect(config.a[:value]).to eq 1
       expect(config_copy.a[:value]).to eq 2
       expect(config.b).to match_array [1, 2, 3]
       expect(config_copy.b).to match_array [1, 2, 3, 5]
+      expect(config.c.value).to match_array %w[a b]
+      expect(config_copy.c.value).to match_array %w[a b c]
     end
   end
 

data/spec/models/blacklight/icon_spec.rb

@@ -17,29 +17,30 @@ RSpec.describe Blacklight::Icon do
     end
     it 'adds title' do
       expect(Capybara.string(subject.svg))
-        .to have_css 'title[id^="bl-icon-search-"]', text: 'search icon'
-    end
-    it 'adds aria-labelledby' do
-      expect(Capybara.string(subject.svg))
-        .to have_css 'svg[aria-labelledby^="bl-icon-search-"]'
+        .to have_css 'title', text: 'Search'
     end
     context 'when label is false' do
       subject { described_class.new(:search, classes: 'awesome', aria_hidden: true, label: false) }
 
       it 'does not add title' do
         expect(Capybara.string(subject.svg))
-          .not_to have_css 'title', text: 'search icon'
+          .not_to have_css 'title', text: 'Search'
       end
-      it 'does not add aria-labelledby' do
+    end
+
+    context ' with a label context' do
+      subject { described_class.new(:search, classes: 'awesome', aria_hidden: true, additional_options: { label_context: 'foo' }) }
+
+      it 'adds title' do
         expect(Capybara.string(subject.svg))
-          .not_to have_css 'svg[aria-labelledby^="bl-icon-search-"]'
+          .to have_css 'title', text: 'Search'
       end
     end
   end
 
   describe '#options' do
     it 'applies options classes and default class' do
-      expect(subject.options[:class]).to eq 'blacklight-icons awesome'
+      expect(subject.options[:class]).to eq 'blacklight-icons blacklight-icon-search awesome'
     end
     it 'applies options aria-hidden=true' do
       expect(subject.options[:'aria-hidden']).to be true
@@ -48,7 +49,7 @@ RSpec.describe Blacklight::Icon do
       subject { described_class.new(:view) }
 
       it 'applies default class with no options' do
-        expect(subject.options[:class]).to eq 'blacklight-icons'
+        expect(subject.options[:class]).to eq 'blacklight-icons blacklight-icon-view'
       end
 
       it 'has no aria-hidden attribute with no options' do