blacklight 9.0.0.beta7 → 9.0.0

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

@@ -43,7 +43,7 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   end
 
   context "with a complex parameter environment" do
-    subject { search_builder.with(user_params).send(:processed_parameters) }
+    subject { search_builder.with(user_params).processed_parameters }
 
     let(:user_params) do
       { :search_field => "test_field", :q => "test query", "facet.field" => "extra_facet" }
@@ -90,7 +90,7 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
   # SPECS for actual search parameter generation
   describe "#processed_parameters" do
     subject do
-      search_builder.with(user_params).send(:processed_parameters)
+      search_builder.with(user_params).processed_parameters
     end
 
     context "when search_params_logic is customized" do
@@ -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' }
@@ -666,6 +718,166 @@ RSpec.describe Blacklight::Solr::SearchBuilderBehavior, :api do
     end
   end
 
+  describe "#add_facet_paging_to_solr" do
+    let(:facet_field) { 'format' }
+    let(:sort_key) { Blacklight::Solr::FacetPaginator.request_keys[:sort] }
+    let(:page_key) { Blacklight::Solr::FacetPaginator.request_keys[:page] }
+    let(:prefix_key) { Blacklight::Solr::FacetPaginator.request_keys[:prefix] }
+
+    let(:blacklight_config) do
+      Blacklight::Configuration.new do |config|
+        config.add_facet_fields_to_solr_request!
+        config.add_facet_field 'format'
+        config.add_facet_field 'format_ordered', sort: :count
+        config.add_facet_field 'format_limited', limit: 5
+        config.add_facet_field 'format_more_limited', limit: 5, more_limit: 50
+      end
+    end
+
+    let(:solr_parameters) do
+      solr_parameters = Blacklight::Solr::Request.new
+      subject.facet(facet_field).add_facet_paging_to_solr(solr_parameters)
+      solr_parameters
+    end
+
+    it 'sets rows to 0' do
+      expect(solr_parameters[:rows]).to eq 0
+    end
+
+    it 'sets facets requested to facet_field argument' do
+      expect(solr_parameters[:'facet.field']).to eq facet_field
+    end
+
+    it 'defaults offset to 0' do
+      expect(solr_parameters[:"f.#{facet_field}.facet.offset"]).to eq 0
+    end
+
+    context 'when offset is manually set' do
+      let(:user_params) { { page_key => 2 } }
+
+      it 'uses offset manually set, and converts it to an integer' do
+        expect(solr_parameters[:"f.#{facet_field}.facet.offset"]).to eq 20
+      end
+    end
+
+    context 'for a field with a configured more_limit' do
+      let(:facet_field) { 'format_more_limited' }
+
+      it 'uses the more_limit configuration' do
+        expect(solr_parameters[:"f.#{facet_field}.facet.limit"]).to eq 51
+      end
+    end
+
+    context 'for a field with a param key different from the field name' do
+      let(:user_params) { { page_key => 2, 'facet.sort': 'index', 'facet.prefix': 'x' } }
+      let(:facet_field) { 'param_key' }
+
+      let(:blacklight_config) do
+        Blacklight::Configuration.new.tap do |config|
+          config.add_facet_field key: 'param_key', field: 'solr_field', more_limit: 50, ex: 'other'
+
+          config.add_facet_fields_to_solr_request!
+        end
+      end
+
+      it "uses the configured solr field name in queries" do
+        expect(solr_parameters).to include 'f.solr_field.facet.limit': 51,
+                                           'f.solr_field.facet.offset': 50,
+                                           'f.solr_field.facet.sort': 'index',
+                                           'f.solr_field.facet.prefix': 'x',
+                                           'facet.field': '{!ex=other}solr_field'
+      end
+    end
+
+    it 'defaults limit to 20' do
+      expect(solr_parameters[:"f.#{facet_field}.facet.limit"]).to eq 21
+    end
+
+    it 'uses the default sort' do
+      expect(solr_parameters[:"f.#{facet_field}.facet.sort"]).to be_blank
+    end
+
+    context 'when sort is provided' do
+      let(:user_params) { { sort_key => 'index' } }
+
+      it 'uses sort provided in the parameters' do
+        expect(solr_parameters[:"f.#{facet_field}.facet.sort"]).to eq 'index'
+      end
+    end
+
+    context 'when a prefix is provided' do
+      let(:user_params) { { prefix_key => 'A' } }
+
+      it 'includes the prefix in the query' do
+        expect(solr_parameters[:"f.#{facet_field}.facet.prefix"]).to eq 'A'
+      end
+    end
+  end
+
+  describe "#add_facet_suggestion_parameters" do
+    it "does not add anything when the builder has no facet_suggestion_query and no facet" do
+      expect(subject.facet).to be_nil
+      expect(subject.facet_suggestion_query).to be_nil
+      solr_params = Blacklight::Solr::Request.new
+
+      expect do
+        subject.add_facet_suggestion_parameters(solr_params)
+      end.not_to(change { solr_params })
+    end
+
+    it "does not add anything when the builder has a facet_suggestion_query but no facet" do
+      subject.facet_suggestion_query = 'artic'
+      expect(subject.facet_suggestion_query).to eq 'artic'
+      expect(subject.facet).to be_nil
+      solr_params = Blacklight::Solr::Request.new
+
+      expect do
+        subject.add_facet_suggestion_parameters(solr_params)
+      end.not_to(change { solr_params })
+    end
+
+    it "does not add anything when the builder has a facet but no facet_suggestion_query" do
+      subject.facet = 'subject_facet'
+      expect(subject.facet_suggestion_query).to be_nil
+      expect(subject.facet).to eq 'subject_facet'
+      solr_params = Blacklight::Solr::Request.new
+
+      expect do
+        subject.add_facet_suggestion_parameters(solr_params)
+      end.not_to(change { solr_params })
+    end
+
+    it "adds the facet_suggestion_query to facet.contains" do
+      subject.facet = 'subject_facet'
+      subject.facet_suggestion_query = 'artic'
+      solr_params = Blacklight::Solr::Request.new
+
+      subject.add_facet_suggestion_parameters(solr_params)
+
+      expect(solr_params[:'facet.contains']).to eq 'artic'
+    end
+
+    it "adds the first part of facet_suggestion_query to facet.contains if it is extremely long" do
+      subject.facet = 'subject_facet'
+      subject.facet_suggestion_query = 'Call me Ishmael. Some years ago—never mind how long precisely'
+      solr_params = Blacklight::Solr::Request.new
+
+      subject.add_facet_suggestion_parameters(solr_params)
+
+      expect(solr_params[:'facet.contains']).to eq 'Call me Ishmael. Some years ago—never mind how long'
+    end
+
+    it "adds facet.contains.ignoreCase" do
+      subject.facet = 'subject_facet'
+      subject.facet_suggestion_query = 'artic'
+      solr_params = Blacklight::Solr::Request.new
+
+      subject.add_facet_suggestion_parameters(solr_params)
+
+      expect(solr_params[:'facet.contains.ignoreCase']).to be true
+    end
+  end
+
   describe "#with_tag_ex" do
     it "adds an !ex local parameter if the facet configuration requests it" do
       expect(subject.with_ex_local_param("xyz", "some-value")).to eq "{!ex=xyz}some-value"
@@ -677,12 +889,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/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/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