blacklight 7.14.1 → 7.15.0

data/spec/components/blacklight/advanced_search_form_component_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::AdvancedSearchFormComponent, type: :component do
+  subject(:render) do
+    component.render_in(view_context)
+  end
+
+  let(:component) { described_class.new(url: '/whatever', response: response, params: params) }
+  let(:response) { Blacklight::Solr::Response.new({ facet_counts: { facet_fields: { format: { 'Book' => 10, 'CD' => 5 } } } }.with_indifferent_access, {}) }
+  let(:params) { {} }
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:view_context) { controller.view_context }
+
+  before do
+    allow(view_context).to receive(:facet_limit_for).and_return(nil)
+  end
+
+  context 'with additional parameters' do
+    let(:params) { { some: :parameter, an_array: [1, 2] } }
+
+    it 'adds additional parameters as hidden fields' do
+      expect(rendered).to have_field 'some', with: 'parameter', type: :hidden
+      expect(rendered).to have_field 'an_array[]', with: '1', type: :hidden
+      expect(rendered).to have_field 'an_array[]', with: '2', type: :hidden
+    end
+  end
+
+  it 'has text fields for each search field' do
+    expect(rendered).to have_selector '.advanced-search-field', count: 4
+    expect(rendered).to have_field 'clause_0_field', with: 'all_fields', type: :hidden
+    expect(rendered).to have_field 'clause_1_field', with: 'title', type: :hidden
+    expect(rendered).to have_field 'clause_2_field', with: 'author', type: :hidden
+    expect(rendered).to have_field 'clause_3_field', with: 'subject', type: :hidden
+  end
+
+  it 'has filters' do
+    expect(rendered).to have_selector '.blacklight-format'
+    expect(rendered).to have_field 'f_inclusive[format][]', with: 'Book'
+    expect(rendered).to have_field 'f_inclusive[format][]', with: 'CD'
+  end
+
+  it 'has a sort field' do
+    expect(rendered).to have_select 'sort', options: %w[relevance year author title]
+  end
+end

data/spec/components/blacklight/document_component_spec.rb

@@ -151,4 +151,19 @@ RSpec.describe Blacklight::DocumentComponent, type: :component do
     expect(rendered).to have_selector 'dd', text: 'Title'
     expect(rendered).not_to have_selector 'dt', text: 'ISBN:'
   end
+
+  context 'with a thumbnail component' do
+    let(:attr) { { thumbnail_component: thumbnail_component_class } }
+    let(:thumbnail_component_class) do
+      Class.new(ViewComponent::Base) do
+        def render_in(view_context)
+          view_context.capture { 'Thumb!' }
+        end
+      end
+    end
+
+    it 'uses the provided thumbnail component' do
+      expect(rendered).to have_content 'Thumb!'
+    end
+  end
 end

data/spec/components/blacklight/facet_field_checkboxes_component_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::FacetFieldCheckboxesComponent, type: :component do
+  subject(:render) do
+    render_inline(described_class.new(facet_field: facet_field))
+  end
+
+  let(:rendered) do
+    Capybara::Node::Simple.new(render)
+  end
+
+  let(:facet_field) do
+    instance_double(
+      Blacklight::FacetFieldPresenter,
+      facet_field: Blacklight::Configuration::NullField.new(key: 'field'),
+      paginator: paginator,
+      key: 'field',
+      label: 'Field',
+      active?: false,
+      collapsed?: false,
+      modal_path: nil,
+      html_id: 'facet-field',
+      search_state: search_state
+    )
+  end
+
+  let(:paginator) do
+    instance_double(Blacklight::FacetPaginator, items: [
+                      double(label: 'a', hits: 10, value: 'a'),
+                      double(label: 'b', hits: 33, value: 'b'),
+                      double(label: 'c', hits: 3, value: 'c')
+                    ])
+  end
+
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+  let(:params) { { f: { field: ['a'] } } }
+
+  it 'renders a collapsible card' do
+    expect(rendered).to have_selector '.card'
+    expect(rendered).to have_button 'Field'
+    expect(rendered).to have_selector 'button[data-target="#facet-field"]'
+    expect(rendered).to have_selector '#facet-field.collapse.show'
+  end
+
+  it 'renders the facet items' do
+    expect(rendered).to have_selector 'ul.facet-values'
+    expect(rendered).to have_selector 'li', count: 3
+
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'a'
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'b'
+    expect(rendered).to have_field 'f_inclusive[field][]', with: 'c'
+  end
+end

data/spec/components/blacklight/facet_field_list_component_spec.rb

@@ -20,7 +20,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
       active?: false,
       collapsed?: false,
       modal_path: nil,
-      html_id: 'facet-field'
+      html_id: 'facet-field',
+      values: []
     )
   end
 
@@ -53,7 +54,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: true,
         collapsed?: false,
         modal_path: nil,
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -72,7 +74,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: false,
         collapsed?: true,
         modal_path: nil,
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -97,7 +100,8 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
         active?: false,
         collapsed?: false,
         modal_path: '/catalog/facet/modal',
-        html_id: 'facet-field'
+        html_id: 'facet-field',
+        values: []
       )
     end
 
@@ -105,4 +109,35 @@ RSpec.describe Blacklight::FacetFieldListComponent, type: :component do
       expect(rendered).to have_link 'more Field', href: '/catalog/facet/modal'
     end
   end
+
+  context 'with inclusive facets' do
+    let(:facet_field) do
+      instance_double(
+        Blacklight::FacetFieldPresenter,
+        paginator: paginator,
+        facet_field: Blacklight::Configuration::NullField.new(key: 'field'),
+        key: 'field',
+        label: 'Field',
+        active?: false,
+        collapsed?: false,
+        modal_path: nil,
+        html_id: 'facet-field',
+        values: [%w[a b c]],
+        search_state: search_state
+      )
+    end
+
+    let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+    let(:params) { { f_inclusive: { field: %w[a b c] } } }
+
+    it 'displays the constraint above the list' do
+      expect(rendered).to have_content 'Any of:'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'a'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=b&f_inclusive%5Bfield%5D%5B%5D=c'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'b'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=a&f_inclusive%5Bfield%5D%5B%5D=c'
+      expect(rendered).to have_selector '.inclusive_or .facet-label', text: 'c'
+      expect(rendered).to have_link '[remove]', href: 'http://test.host/catalog?f_inclusive%5Bfield%5D%5B%5D=a&f_inclusive%5Bfield%5D%5B%5D=b'
+    end
+  end
 end

data/spec/controllers/catalog_controller_spec.rb

@@ -301,6 +301,15 @@ RSpec.describe CatalogController, api: true do
     end
   end
 
+  describe 'GET advanced_search' do
+    it 'renders an advanced search form' do
+      get :advanced_search
+      expect(response).to be_successful
+
+      assert_facets_have_values(assigns(:response).aggregations)
+    end
+  end
+
   # SHOW ACTION
   describe "show action" do
     describe "with format :html" do

data/spec/features/advanced_search_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe "Blacklight Advanced Search Form" do
+  describe "advanced search form" do
+    before do
+      visit '/catalog/advanced?hypothetical_existing_param=true&q=ignore+this+existing+query'
+    end
+
+    it "has field and facet blocks" do
+      expect(page).to have_selector('.query-criteria')
+      expect(page).to have_selector('.limit-criteria')
+    end
+
+    describe "query column" do
+      it "gives the user a choice between and/or queries" do
+        expect(page).to have_selector('#op')
+        within('#op') do
+          expect(page).to have_selector('option[value="must"]')
+          expect(page).to have_selector('option[value="should"]')
+        end
+      end
+
+      it "lists the configured search fields" do
+        expect(page).to have_field 'All Fields'
+        expect(page).to have_field 'Title'
+        expect(page).to have_field 'Author'
+        expect(page).to have_field 'Subject'
+      end
+    end
+
+    describe "facet column" do
+      it "lists facets" do
+        expect(page).to have_selector('.blacklight-language_ssim')
+
+        within('.blacklight-language_ssim') do
+          expect(page).to have_content 'Language'
+        end
+      end
+    end
+
+    it 'scopes searches to fields' do
+      fill_in 'Title', with: 'Medicine'
+      click_on 'advanced-search-submit'
+      expect(page).to have_content 'Remove constraint Title: Medicine'
+      expect(page).to have_content 'Strong Medicine speaks'
+    end
+  end
+
+  describe "prepopulated advanced search form" do
+    before do
+      visit '/catalog/advanced?op=must&clause[0][field]=title&clause[0]query=medicine'
+    end
+
+    it "does not create hidden inputs for search fields" do
+      expect(page).to have_field 'Title', with: 'medicine'
+    end
+
+    it "does not have multiple parameters for a search field" do
+      fill_in 'Title', with: 'bread'
+      click_on 'advanced-search-submit'
+      expect(page.current_url).to match(/bread/)
+      expect(page.current_url).not_to match(/medicine/)
+    end
+  end
+end

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

@@ -72,6 +72,33 @@ RSpec.describe Blacklight::SearchState::FilterField do
         expect(new_state.filter('some_field').values).to eq %w[1 2 4]
       end
     end
+
+    context 'with an array' do
+      let(:params) do
+        { f: { another_field: ['3'] }, f_inclusive: { some_field: %w[a b c] } }
+      end
+
+      it 'creates a new group with the new values' do
+        filter = search_state.filter('new_field')
+        new_state = filter.add(%w[x y z])
+
+        expect(new_state.filter('new_field').values).to eq [%w[x y z]]
+      end
+
+      it 'updates any existing groups with the new values' do
+        filter = search_state.filter('some_field')
+        new_state = filter.add(%w[x y z])
+
+        expect(new_state.filter('some_field').values).to eq [%w[x y z]]
+      end
+
+      it 'leaves existing filters alone' do
+        filter = search_state.filter('another_field')
+        new_state = filter.add(%w[x y z])
+
+        expect(new_state.filter('another_field').values).to eq ['3', %w[x y z]]
+      end
+    end
   end
 
   describe '#remove' do
@@ -104,12 +131,50 @@ RSpec.describe Blacklight::SearchState::FilterField do
 
       expect(new_state.filter('some_field').values).to eq ['2']
     end
+
+    context 'with an array' do
+      let(:params) do
+        { f: { another_field: ['3'] }, f_inclusive: { some_field: %w[a b c], another_field: %w[x y z] } }
+      end
+
+      it 'removes groups of values' do
+        filter = search_state.filter('some_field')
+        new_state = filter.remove(%w[a b c])
+
+        expect(new_state.params[:f_inclusive]).not_to include :some_field
+        expect(new_state.filter('some_field').values).to eq []
+      end
+
+      it 'can remove single values' do
+        filter = search_state.filter('some_field')
+        new_state = filter.remove(%w[a])
+
+        expect(new_state.filter('some_field').values).to eq [%w[b c]]
+      end
+
+      it 'leaves existing filters alone' do
+        filter = search_state.filter('another_field')
+        new_state = filter.remove(%w[x y z])
+
+        expect(new_state.filter('another_field').values).to eq ['3']
+      end
+    end
   end
 
   describe '#values' do
     it 'returns the currently selected values of the filter' do
       expect(search_state.filter('some_field').values).to eq %w[1 2]
     end
+
+    context 'with an array' do
+      let(:params) do
+        { f: { some_field: ['3'] }, f_inclusive: { some_field: %w[a b c] } }
+      end
+
+      it 'combines the exclusive and inclusive values' do
+        expect(search_state.filter('some_field').values).to eq ['3', %w[a b c]]
+      end
+    end
   end
 
   describe '#include?' do

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

@@ -134,6 +134,18 @@ RSpec.describe Blacklight::Solr::Repository, api: true do
         end
       end
     end
+
+    context 'with json parameters' do
+      it 'sends a post request with some json' do
+        allow(subject.connection).to receive(:send_and_receive) do |path, params|
+          expect(path).to eq 'select'
+          expect(params[:method]).to eq :post
+          expect(JSON.parse(params[:data]).with_indifferent_access).to include(query: { bool: {} })
+          expect(params[:headers]).to include({ 'Content-Type' => 'application/json' })
+        end.and_return('response' => { 'docs' => [] })
+        subject.search(json: { query: { bool: {} } })
+      end
+    end
   end
 
   describe "http_method configuration", integration: true do

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

@@ -259,6 +259,17 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, api: true do
       end
     end
 
+    describe 'with multi-valued facets' do
+      let(:user_params) { { f_inclusive: { format: %w[Book Movie CD] } } }
+
+      it "has proper solr parameters" do
+        expect(subject[:fq]).to include('{!lucene}{!query v=$f_inclusive.format.0} OR {!query v=$f_inclusive.format.1} OR {!query v=$f_inclusive.format.2}')
+        expect(subject['f_inclusive.format.0']).to eq '{!term f=format}Book'
+        expect(subject['f_inclusive.format.1']).to eq '{!term f=format}Movie'
+        expect(subject['f_inclusive.format.2']).to eq '{!term f=format}CD'
+      end
+    end
+
     describe "solr parameters for a field search from config (subject)" do
       let(:user_params) { subject_search_params }
 
@@ -723,4 +734,21 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, api: true do
       expect(subject.with_ex_local_param(nil, "some-value")).to eq "some-value"
     end
   end
+
+  context 'with advanced search clause parameters' do
+    before do
+      blacklight_config.search_fields.each_value do |v|
+        v.clause_params = { edismax: v.solr_parameters.dup }
+      end
+    end
+
+    let(:user_params) { { op: 'must', clause: { '0': { field: 'title', query: 'the book' }, '1': { field: 'author', query: 'the person' } } } }
+
+    it "has proper solr parameters" do
+      expect(subject.to_hash.with_indifferent_access.dig(:json, :query, :bool, :must, 0, :edismax, :query)).to eq 'the book'
+      expect(subject.to_hash.with_indifferent_access.dig(:json, :query, :bool, :must, 0, :edismax, :qf)).to eq '${title_qf}'
+      expect(subject.to_hash.with_indifferent_access.dig(:json, :query, :bool, :must, 1, :edismax, :query)).to eq 'the person'
+      expect(subject.to_hash.with_indifferent_access.dig(:json, :query, :bool, :must, 1, :edismax, :qf)).to eq '${author_qf}'
+    end
+  end
 end

data/spec/presenters/blacklight/clause_presenter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Blacklight::ClausePresenter, type: :presenter do
+  subject(:presenter) do
+    described_class.new('0', params.with_indifferent_access.dig(:clause, '0'), field_config, controller.view_context, search_state)
+  end
+
+  let(:field_config) { Blacklight::Configuration::NullField.new key: 'some_field' }
+  let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, Blacklight::Configuration.new) }
+  let(:params) { {} }
+
+  describe '#field_label' do
+    it 'returns a label for the field' do
+      expect(subject.field_label).to eq 'Some Field'
+    end
+  end
+
+  describe '#label' do
+    let(:params) { { clause: { '0' => { query: 'some search string' } } } }
+
+    it 'returns the query value for the clause' do
+      expect(subject.label).to eq 'some search string'
+    end
+  end
+
+  describe '#remove_href' do
+    let(:params) { { clause: { '0' => { query: 'some_search_string' } } } }
+
+    it 'returns the href to remove the search clause' do
+      expect(subject.remove_href).not_to include 'some_search_string'
+    end
+  end
+end