blacklight 9.0.0.beta6 → 9.0.0.beta8

data/spec/models/blacklight/configuration_spec.rb

@@ -735,4 +735,130 @@ RSpec.describe Blacklight::Configuration, :api do
       described_class.default_configuration.delete_at(2)
     end
   end
+
+  describe "#copy_search_field_config_to_advanced!" do
+    let(:config) { described_class.new }
+
+    before do
+      config.add_search_field('title',
+                              solr_parameters: {
+                                'spellcheck.dictionary': 'title',
+                                qf: '${title_qf}',
+                                pf: '${title_pf}'
+                              })
+      config.add_search_field('excluded_field',
+                              solr_parameters: { qf: '${excluded_qf}' },
+                              include_in_advanced_search: false)
+      config.add_search_field('already_configured',
+                              solr_parameters: { qf: '${configured_qf}' },
+                              clause_params: { edismax: { existing_custom: 'params' } })
+    end
+
+    it "copies solr_parameters to clause_params for eligible search fields" do
+      config.copy_search_field_config_to_advanced!
+
+      title_field = config.search_fields['title']
+      expect(title_field.clause_params).to be_present
+      expect(title_field.clause_params[:edismax]).to eq({ 'spellcheck.dictionary': 'title', qf: '${title_qf}', pf: '${title_pf}' })
+    end
+
+    it "skips fields with include_in_advanced_search set to false" do
+      config.copy_search_field_config_to_advanced!
+
+      excluded_field = config.search_fields['excluded_field']
+      expect(excluded_field.clause_params).to be_nil
+    end
+
+    it "skips fields that already have a clause_params config" do
+      config.copy_search_field_config_to_advanced!
+
+      already_configured_field = config.search_fields['already_configured']
+      expect(already_configured_field.clause_params).to eq({ edismax: { existing_custom: 'params' } })
+    end
+
+    it "handles fields with nil solr_parameters" do
+      config.add_search_field('no_solr_params')
+
+      expect { config.copy_search_field_config_to_advanced! }.not_to raise_error
+
+      field = config.search_fields['no_solr_params']
+      expect(field.clause_params).to be_present
+      expect(field.clause_params[:edismax]).to eq({})
+    end
+  end
+
+  describe "#copy_facet_field_config_to_advanced!" do
+    let(:config) { described_class.new }
+
+    before do
+      config.add_facet_field('format',
+                             field: 'format')
+      config.add_facet_field('subject_ssim')
+      config.add_facet_field('excluded_facet',
+                             field: 'excluded_field',
+                             include_in_advanced_search: false)
+      config.add_facet_field('query_facet',
+                             query: { 'recent' => { fq: 'pub_date_ssim:[2020 TO *]' } })
+      config.add_facet_field('pivot_facet',
+                             pivot: %w[author_ssim subject_ssim])
+      config.add_facet_field('range_facet',
+                             range: true,
+                             field: 'pub_date_ssim')
+    end
+
+    it "sets default facet.sort to 'count'" do
+      config.copy_facet_field_config_to_advanced!
+
+      expect(config.advanced_search.form_solr_parameters['facet.sort']).to eq 'count'
+    end
+
+    it "adds eligible facet fields to facet.field array" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).to eq(%w[format subject_ssim])
+    end
+
+    it "skips fields with include_in_advanced_search set to false" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).not_to include('excluded_field')
+    end
+
+    it "skips fields that are query, pivot, or range facets" do
+      config.copy_facet_field_config_to_advanced!
+
+      facet_fields = config.advanced_search.form_solr_parameters['facet.field']
+      expect(facet_fields).not_to include('query_facet', 'pivot_facet', 'range_facet')
+    end
+
+    it "sets facet limit to -1 to show all values for eligible fields" do
+      config.copy_facet_field_config_to_advanced!
+
+      expect(config.advanced_search.form_solr_parameters['f.format.facet.limit']).to eq(-1)
+      expect(config.advanced_search.form_solr_parameters['f.subject_ssim.facet.limit']).to eq(-1)
+    end
+
+    context "preserving existing advanced search config if present" do
+      before do
+        config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'index',
+          'f.subject_ssim.facet.limit' => 50
+        }
+      end
+
+      it "preserves existing facet.limit configuration if set" do
+        config.copy_facet_field_config_to_advanced!
+
+        expect(config.advanced_search.form_solr_parameters['f.subject_ssim.facet.limit']).to eq(50)
+      end
+
+      it "preserves existing default facet.sort configuration if set" do
+        config.copy_facet_field_config_to_advanced!
+
+        expect(config.advanced_search.form_solr_parameters['facet.sort']).to eq('index')
+      end
+    end
+  end
 end

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

@@ -87,6 +87,12 @@ RSpec.describe Blacklight::Solr::Repository, :api do
       expect(subject.search(params: {})).to be_a Blacklight::Solr::Response
     end
 
+    it "can be called with no args" do
+      blacklight_config.solr_path = 'xyz'
+      allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
+      expect(subject.search).to be_a Blacklight::Solr::Response
+    end
+
     it "uses the default solr path" do
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
       expect(subject.search(params: {})).to be_a Blacklight::Solr::Response

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

@@ -523,6 +523,58 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
     end
   end
 
+  describe "#add_facets_for_advanced_search_form" do
+    let(:solr_parameters) { Blacklight::Solr::Request.new }
+    let(:mock_controller) { instance_double(CatalogController, action_name: 'advanced_search') }
+    let(:mock_search_state) { instance_double(Blacklight::SearchState, controller: mock_controller) }
+
+    before do
+      allow(search_builder).to receive(:search_state).and_return(mock_search_state)
+    end
+
+    context "when action is advanced_search and form_solr_parameters are configured" do
+      before do
+        blacklight_config.advanced_search.enabled = true
+        blacklight_config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'count',
+          'facet.field' => %w[format subject_ssim],
+          'f.format.facet.limit' => -1,
+          'f.subject_ssim.facet.limit' => -1
+        }
+      end
+
+      it "merges advanced search form parameters into solr parameters" do
+        solr_parameters['existing.param'] = 'keep_me'
+        subject.add_facets_for_advanced_search_form(solr_parameters)
+
+        expect(solr_parameters['facet.sort']).to eq 'count'
+        expect(solr_parameters['facet.field']).to eq %w[format subject_ssim]
+        expect(solr_parameters['f.format.facet.limit']).to eq(-1)
+        expect(solr_parameters['f.subject_ssim.facet.limit']).to eq(-1)
+        expect(solr_parameters['existing.param']).to eq 'keep_me'
+      end
+    end
+
+    context "when action is not advanced_search" do
+      before do
+        allow(mock_controller).to receive(:action_name).and_return('index')
+        blacklight_config.advanced_search.enabled = true
+        blacklight_config.advanced_search.form_solr_parameters = {
+          'facet.sort' => 'count',
+          'facet.field' => ['format']
+        }
+      end
+
+      it "does not merge advanced search form parameters" do
+        solr_parameters['f.format.facet.limit'] = 21
+
+        subject.add_facets_for_advanced_search_form(solr_parameters)
+
+        expect(solr_parameters['f.format.facet.limit']).to eq 21
+      end
+    end
+  end
+
   describe "#add_facet_fq_to_solr" do
     it "converts a String fq into an Array" do
       solr_parameters = { fq: 'a string' }
@@ -677,12 +729,6 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   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

data/spec/presenters/blacklight/constraint_presenter_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::ConstraintPresenter, type: :presenter do
+  subject(:presenter) do
+    described_class.new(facet_item_presenter: facet_item_presenter, field_label: field_label)
+  end
+
+  let(:facet_item_presenter) do
+    instance_double(Blacklight::FacetItemPresenter, label: 'item 1', remove_href: '/catalog')
+  end
+  let(:field_label) { 'field 1' }
+
+  describe '#constraint_label' do
+    subject { presenter.constraint_label }
+
+    it { is_expected.to eq 'item 1' }
+  end
+
+  describe '#field_label' do
+    subject { presenter.field_label }
+
+    it { is_expected.to eq 'field 1' }
+  end
+
+  describe '#remove_href' do
+    subject { presenter.remove_href }
+
+    it { is_expected.to eq '/catalog' }
+  end
+end

data/spec/presenters/blacklight/document_presenter_spec.rb

@@ -29,13 +29,13 @@ RSpec.describe Blacklight::DocumentPresenter do
   end
 
   describe '#field_value' do
-    let(:field_presenter) { instance_double(Blacklight::FieldPresenter, render: 'xyz') }
+    let(:field_presenter) { instance_double(Blacklight::FieldPresenter, render: ['xyz']) }
     let(:field_config) { Blacklight::Configuration::DisplayField.new }
     let(:options) { { a: 1 } }
 
     it 'calls the field presenter' do
       allow(Blacklight::FieldPresenter).to receive(:new).with(request_context, doc, field_config, options).and_return(field_presenter)
-      expect(presenter.field_value(field_config, options)).to eq 'xyz'
+      expect(presenter.field_value(field_config, options)).to eq ['xyz']
     end
 
     it 'can be configured to use an alternate presenter' do
@@ -44,7 +44,7 @@ RSpec.describe Blacklight::DocumentPresenter do
       field_config.presenter = SomePresenter
       allow(SomePresenter).to receive(:new).and_return(instance)
 
-      expect(presenter.field_value(field_config, options)).to eq 'abc'
+      expect(presenter.field_value(field_config, options)).to eq ['abc']
     end
   end
 

data/spec/presenters/blacklight/facet_item_presenter_spec.rb

@@ -56,13 +56,6 @@ RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
     end
   end
 
-  describe '#constraint_label' do
-    it 'provides the label for the constraint' do
-      allow(facet_config).to receive_messages(query: nil, date: nil, helper_method: nil, url_method: nil)
-      expect(presenter.constraint_label).to eq presenter.label
-    end
-  end
-
   describe '#href' do
     let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: false) }
 

data/spec/presenters/blacklight/field_presenter_spec.rb

@@ -6,6 +6,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
   let(:request_context) { double('View context', params: { x: '1' }, search_state: search_state, should_render_field?: true, blacklight_config: config) }
   let(:document) do
     SolrDocument.new(id: 1,
+                     'join_true' => %w[a b c],
+                     'separator_options' => %w[d e f],
                      'link_to_facet_true' => 'x',
                      'link_to_facet_named' => 'x',
                      'qwer' => 'document qwer value',
@@ -30,6 +32,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     Blacklight::Configuration.new.configure do |config|
       config.add_index_field 'qwer'
       config.add_index_field 'asdf', helper_method: :render_asdf_index_field
+      config.add_index_field 'join_true', join: true
+      config.add_index_field 'separator_options', separator_options: { words_connector: '<br/>', last_word_connector: '<br/>' }
       config.add_index_field 'link_to_facet_true', link_to_facet: true
       config.add_index_field 'link_to_facet_named', link_to_facet: :some_field
       config.add_index_field 'highlight', highlight: true
@@ -40,6 +44,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       config.add_index_field 'alias', field: 'qwer'
       config.add_index_field 'with_default', default: 'value'
       config.add_index_field 'with_steps', steps: [custom_step]
+      config.add_index_field :some_field
       config.add_facet_field :link_to_facet_true
       config.add_facet_field :some_field
     end
@@ -51,25 +56,33 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     context 'when an explicit html value is provided' do
       let(:options) { { value: '<b>val1</b>' } }
 
-      it { is_expected.not_to be_html_safe }
+      it { is_expected.to eq(['<b>val1</b>']) }
+
+      it 'does not mark value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
     end
 
     context 'when an explicit array value with unsafe characters is provided' do
       let(:options) { { value: ['<a', 'b'] } }
 
-      it { is_expected.to eq('&lt;a and b').and be_html_safe }
+      it { is_expected.to eq(%w[<a b]) }
+
+      it 'does not mark values as html_safe' do
+        expect(subject.all?(&:html_safe?)).not_to be true
+      end
     end
 
     context 'when an explicit array value is provided' do
       let(:options) { { value: %w[a b c] } }
 
-      it { is_expected.to eq 'a, b, and c' }
+      it { is_expected.to eq %w[a b c] }
     end
 
     context 'when an explicit value is provided' do
       let(:options) { { value: 'asdf' } }
 
-      it { is_expected.to eq 'asdf' }
+      it { is_expected.to eq ['asdf'] }
     end
 
     context 'when field has a helper method' do
@@ -77,7 +90,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
         allow(request_context).to receive(:render_asdf_index_field).and_return('custom asdf value')
       end
 
-      it { is_expected.to eq 'custom asdf value' }
+      it { is_expected.to eq ['custom asdf value'] }
     end
 
     context 'when field has link_to_facet with true' do
@@ -88,7 +101,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_true' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when field has link_to_facet with a field name' do
@@ -99,7 +112,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_named' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when no highlight field is available' do
@@ -120,14 +133,14 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'highlight' }
 
-      it { is_expected.to eq '<em>highlight</em>' }
+      it { is_expected.to eq ['<em>highlight</em>'] }
     end
 
     context 'when no options are provided' do
       let(:field_name) { 'qwer' }
 
       it "checks the document field value" do
-        expect(subject).to eq 'document qwer value'
+        expect(subject).to eq ['document qwer value']
       end
     end
 
@@ -138,7 +151,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'solr_doc_accessor' }
 
-      it { is_expected.to eq '123' }
+      it { is_expected.to eq ['123'] }
     end
 
     context 'when accessor is set to a value' do
@@ -147,7 +160,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessor with the field_name as the argument' do
         expect(document).to receive(:solr_doc_accessor).with('explicit_accessor').and_return("123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -157,7 +170,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessors on the return of the preceeding' do
         allow(document).to receive_message_chain(:solr_doc_accessor, some_method: "123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -165,26 +178,26 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       let(:field_name) { 'explicit_values_with_context' }
 
       it 'calls the accessors on the return of the preceeding' do
-        expect(subject).to eq '1'
+        expect(subject).to eq ['1']
       end
     end
 
     context 'when the field is an alias' do
       let(:field_name) { 'alias' }
 
-      it { is_expected.to eq 'document qwer value' }
+      it { is_expected.to eq ['document qwer value'] }
     end
 
     context 'when the field has a default' do
       let(:field_name) { 'with_default' }
 
-      it { is_expected.to eq 'value' }
+      it { is_expected.to eq ['value'] }
     end
 
     context 'with steps' do
       let(:field_name) { 'with_steps' }
 
-      it { is_expected.to eq 'Static step' }
+      it { is_expected.to eq ['Static step'] }
     end
 
     context 'for a field with the helper_method option' do
@@ -200,12 +213,80 @@ RSpec.describe Blacklight::FieldPresenter, :api do
           args.first
         end
 
-        expect(result).to include :document, :field, :value, :config, :a
-        expect(result[:document]).to eq document
-        expect(result[:field]).to eq 'field_with_helper'
-        expect(result[:value]).to eq ['value']
-        expect(result[:config]).to eq field_config
-        expect(result[:a]).to eq 1
+        expect(result).to contain_exactly({ document: document, field: field_name,
+                                            value: ['value'], config: field_config, a: 1 })
+      end
+    end
+
+    context 'when joining a field' do
+      context 'with join config' do
+        let(:field_name) { :join_true }
+
+        it { is_expected.to eq ['a, b, and c'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with separator_options' do
+        let(:field_name) { :separator_options }
+
+        it { is_expected.to eq ['d<br/>e<br/>f'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with join option' do
+        let(:options) { { join: true } }
+        let(:field_name) { 'some_field' }
+
+        it { is_expected.to eq ['1 and 2'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+    end
+
+    context 'with a single value' do
+      let(:options) { { join: true, value: 1 } }
+
+      it 'is not joined' do
+        expect(result).to eq [1]
+      end
+    end
+
+    context 'with a single html value' do
+      let(:options) { { join: true, value: '<b>value</b>' } }
+
+      it { is_expected.to eq ['<b>value</b>'] }
+
+      it 'does not mark the value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
+    end
+
+    context 'when an array containing unsafe characters provided' do
+      let(:options) { { join: true, value: ['<a', 'b'] } }
+
+      it 'html escapes the unsafe characters' do
+        expect(result).to eq ["&lt;a and b"]
+      end
+
+      it 'marks the value as html_safe' do
+        expect(result.first).to be_html_safe
+      end
+    end
+
+    context 'when outside the html context' do
+      let(:field_name) { :join_true }
+      let(:options) { { format: 'json' } }
+
+      it 'does not join the values' do
+        expect(result).to eq %w[a b c]
       end
     end
   end