blacklight 6.19.1 → 7.1.0

data/spec/presenters/blacklight/json_presenter_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Blacklight::JsonPresenter, api: true do
+  let(:response) do
+    instance_double(Blacklight::Solr::Response,
+                    documents: docs,
+                    prev_page: nil,
+                    next_page: 2,
+                    total_pages: 3,
+                    aggregations: aggregations)
+  end
+  let(:docs) do
+    [
+      SolrDocument.new(id: '123', title_tsim: 'Book1', author_tsim: 'Julie'),
+      SolrDocument.new(id: '456', title_tsim: 'Book2', author_tsim: 'Rosie')
+    ]
+  end
+
+  let(:aggregations) do
+    { 'format_si' => Blacklight::Solr::Response::Facets::FacetField.new("format_si", [{ label: "Book", value: 'Book', hits: 20 }]) }
+  end
+
+  let(:config) do
+    Blacklight::Configuration.new do |config|
+      config.add_facet_field 'format', field: 'format_si', label: 'Format'
+      config.add_index_field 'title_tsim', label: 'Title:'
+    end
+  end
+
+  let(:presenter) { described_class.new(response, config) }
+
+  describe '#search_facets' do
+    let(:search_facets) { presenter.search_facets }
+
+    context 'with defined facets that are present in the response' do
+      it 'returns them' do
+        expect(search_facets.map(&:name)).to eq ['format_si']
+      end
+    end
+
+    context 'when there are defined facets that are not in the response' do
+      before do
+        config.add_facet_field 'example_query_facet_field', label: 'Publish Date', query: {}
+      end
+
+      let(:aggregations) do
+        {
+          'format_si' => Blacklight::Solr::Response::Facets::FacetField.new("format_si", [{ label: "Book", value: 'Book', hits: 20 }]),
+          'example_query_facet_field' => Blacklight::Solr::Response::Facets::FacetField.new("example_query_facet_field", [])
+        }
+      end
+
+      it 'filters out the facets that are not defined' do
+        expect(search_facets.map(&:name)).to eq ['format_si']
+      end
+    end
+  end
+end

data/spec/presenters/blacklight/link_alternate_presenter_spec.rb

@@ -12,6 +12,7 @@ RSpec.describe Blacklight::LinkAlternatePresenter do
   let(:search_state) { Blacklight::SearchState.new(params, config, controller) }
 
   let(:presenter) { described_class.new(view_context, document, options) }
+
   before do
     allow(view_context).to receive(:search_state).and_return(search_state)
     allow(view_context).to receive(:polymorphic_url) do |doc, opts|
@@ -21,11 +22,13 @@ RSpec.describe Blacklight::LinkAlternatePresenter do
 
   describe "#render" do
     subject { presenter.render }
+
     let(:expected_html) do
       '<link rel="alternate" title="xml" type="application/xml" href="http://test.host/catalog/9999.xml" />' \
       '<link rel="alternate" title="dc_xml" type="text/xml" href="http://test.host/catalog/9999.dc_xml" />' \
       '<link rel="alternate" title="oai_dc_xml" type="text/xml" href="http://test.host/catalog/9999.oai_dc_xml" />'
     end
+
     it { is_expected.to be_equivalent_to expected_html }
   end
 end

data/spec/presenters/blacklight/search_bar_presenter_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe Blacklight::SearchBarPresenter do
+  let(:controller) { CatalogController.new }
+  let(:presenter) { described_class.new(controller, blacklight_config) }
+  let(:blacklight_config) { Blacklight::Configuration.new }
+
+  describe '#autocomplete_enabled?' do
+    subject { presenter.autocomplete_enabled? }
+
+    describe 'with autocomplete config' do
+      let(:blacklight_config) do
+        Blacklight::Configuration.new.configure do |config|
+          config.autocomplete_enabled = true
+          config.autocomplete_path = 'suggest'
+        end
+      end
+
+      it { is_expected.to be true }
+    end
+
+    describe 'without disabled config' do
+      let(:blacklight_config) do
+        Blacklight::Configuration.new.configure do |config|
+          config.autocomplete_enabled = false
+          config.autocomplete_path = 'suggest'
+        end
+      end
+
+      it { is_expected.to be false }
+    end
+
+    describe 'without path config' do
+      let(:blacklight_config) do
+        Blacklight::Configuration.new.configure do |config|
+          config.autocomplete_enabled = true
+        end
+      end
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "#autofocus?" do
+    subject { presenter.autofocus? }
+
+    context "on a catalog-like index page without query or facet parameters" do
+      before do
+        allow(controller).to receive(:action_name).and_return('index')
+        allow(controller).to receive(:has_search_parameters?).and_return(false)
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context "when not the catalog controller" do
+      let(:controller) { ApplicationController.new }
+
+      it { is_expected.to be false }
+    end
+
+    context "when on the catalog controller show page" do
+      before do
+        allow(controller).to receive(:action_name).and_return('show')
+      end
+
+      it { is_expected.to be false }
+    end
+
+    context "when search parameters are provided" do
+      before do
+        allow(controller).to receive(:has_search_parameters?).and_return(true)
+      end
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/presenters/{show_presenter_spec.rb → blacklight/show_presenter_spec.rb}

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-describe Blacklight::ShowPresenter do
+RSpec.describe Blacklight::ShowPresenter, api: true do
   include Capybara::RSpecMatchers
+  subject { presenter }
+
   let(:request_context) { double }
   let(:config) { Blacklight::Configuration.new }
 
-  subject { presenter }
   let(:presenter) { described_class.new(document, request_context, config) }
   let(:parameter_class) { ActionController::Parameters }
   let(:params) { parameter_class.new }
@@ -14,8 +15,8 @@ describe Blacklight::ShowPresenter do
 
   let(:document) do
     SolrDocument.new(id: 1,
-                     'link_to_search_true' => 'x',
-                     'link_to_search_named' => 'x',
+                     'link_to_facet_true' => 'x',
+                     'link_to_facet_named' => 'x',
                      'qwer' => 'document qwer value')
   end
 
@@ -30,14 +31,23 @@ describe Blacklight::ShowPresenter do
       end
 
       module MockExtension
-         def self.extended(document)
-           document.will_export_as(:weird, "application/weird")
-           document.will_export_as(:weirder, "application/weirder")
-           document.will_export_as(:weird_dup, "application/weird")
-         end
-         def export_as_weird ; "weird" ; end
-         def export_as_weirder ; "weirder" ; end
-         def export_as_weird_dup ; "weird_dup" ; end
+        def self.extended(document)
+          document.will_export_as(:weird, "application/weird")
+          document.will_export_as(:weirder, "application/weirder")
+          document.will_export_as(:weird_dup, "application/weird")
+        end
+
+        def export_as_weird
+          "weird"
+        end
+
+        def export_as_weirder
+          "weirder"
+        end
+
+        def export_as_weird_dup
+          "weird_dup"
+        end
       end
 
       MockDocument.use_extension(MockExtension)
@@ -59,8 +69,8 @@ describe Blacklight::ShowPresenter do
       it "generates <link rel=alternate> tags" do
         tmp_value = Capybara.ignore_hidden_elements
         Capybara.ignore_hidden_elements = false
-        document.export_formats.each_pair do |format, spec|
-          expect(subject).to have_selector("link[href$='.#{ format  }']") do |matches|
+        document.export_formats.each_pair do |format, _spec|
+          expect(subject).to have_selector("link[href$='.#{format}']") do |matches|
             expect(matches).to have(1).match
             tag = matches[0]
             expect(tag.attributes["rel"].value).to eq "alternate"
@@ -87,10 +97,11 @@ describe Blacklight::ShowPresenter do
 
     context "with exclude" do
       subject { presenter.link_rel_alternates(unique: true) }
+
       it "excludes formats from :exclude" do
         tmp_value = Capybara.ignore_hidden_elements
         Capybara.ignore_hidden_elements = false
-        expect(subject).to_not have_selector("link[href$='.weird_dup']")
+        expect(subject).not_to have_selector("link[href$='.weird_dup']")
         Capybara.ignore_hidden_elements = tmp_value
       end
     end
@@ -105,8 +116,8 @@ describe Blacklight::ShowPresenter do
       Blacklight::Configuration.new.configure do |config|
         config.add_show_field 'qwer'
         config.add_show_field 'asdf', helper_method: :render_asdf_document_show_field
-        config.add_show_field 'link_to_search_true', link_to_search: true
-        config.add_show_field 'link_to_search_named', link_to_search: :some_field
+        config.add_show_field 'link_to_facet_true', link_to_facet: true
+        config.add_show_field 'link_to_facet_named', link_to_facet: :some_field
         config.add_show_field 'highlight', highlight: true
         config.add_show_field 'solr_doc_accessor', accessor: true
         config.add_show_field 'explicit_accessor', accessor: :solr_doc_accessor
@@ -114,15 +125,6 @@ describe Blacklight::ShowPresenter do
       end
     end
 
-    context 'when a name is provided' do
-      subject { presenter.field_value 'qwer' }
-
-      it 'raises a deprecation' do
-        expect(Deprecation).to receive(:warn)
-        expect(subject).to eq 'document qwer value'
-      end
-    end
-
     context 'when an explicit html value is provided' do
       subject { presenter.field_value field, value: '<b>val1</b>' }
 
@@ -155,24 +157,24 @@ describe Blacklight::ShowPresenter do
       it { is_expected.to eq 'custom asdf value' }
     end
 
-    context 'when field has link_to_search with true' do
+    context 'when field has link_to_facet with true' do
       before do
-        allow(request_context).to receive(:search_action_path).with('f' => { 'link_to_search_true' => ['x'] }).and_return('/foo')
+        allow(request_context).to receive(:search_action_path).with('f' => { 'link_to_facet_true' => ['x'] }).and_return('/foo')
         allow(request_context).to receive(:link_to).with("x", '/foo').and_return('bar')
       end
 
-      let(:field_name) { 'link_to_search_true' }
+      let(:field_name) { 'link_to_facet_true' }
 
       it { is_expected.to eq 'bar' }
     end
 
-    context 'when field has link_to_search with a field name' do
+    context 'when field has link_to_facet with a field name' do
       before do
         allow(request_context).to receive(:search_action_path).with('f' => { 'some_field' => ['x'] }).and_return('/foo')
         allow(request_context).to receive(:link_to).with("x", '/foo').and_return('bar')
       end
 
-      let(:field_name) { 'link_to_search_named' }
+      let(:field_name) { 'link_to_facet_named' }
 
       it { is_expected.to eq 'bar' }
     end
@@ -248,6 +250,18 @@ describe Blacklight::ShowPresenter do
     end
   end
 
+  describe '#fields' do
+    let(:field) { instance_double(Blacklight::Configuration::Field) }
+
+    before do
+      allow(config).to receive(:show_fields_for).and_return(title: field)
+    end
+
+    it 'returns the list from the configs' do
+      expect(subject.send(:fields)).to eq(title: field)
+    end
+  end
+
   describe "#heading" do
     it "falls back to an id" do
       allow(document).to receive(:[]).with('id').and_return "xyz"
@@ -296,9 +310,8 @@ describe Blacklight::ShowPresenter do
     context 'for a field with the helper_method option' do
       let(:field_name) { 'field_with_helper' }
       let(:field_config) { config.add_facet_field 'field_with_helper', helper_method: 'render_field_with_helper' }
-
-      before do
-        document['field_with_helper'] = 'value'
+      let(:document) do
+        SolrDocument.new(id: 1, 'field_with_helper' => 'value')
       end
 
       it "checks call the helper method with arguments" do
@@ -306,8 +319,6 @@ describe Blacklight::ShowPresenter do
           args.first
         end
 
-        render_options = { a: 1 }
-
         options = subject.send(:field_values, field_config, a: 1)
 
         expect(options).to include :document, :field, :value, :config, :a
@@ -319,30 +330,4 @@ describe Blacklight::ShowPresenter do
       end
     end
   end
-
-  describe 'deprecated methods' do
-    before do
-      allow(Deprecation).to receive(:warn)
-    end
-
-    let(:field_config) { config.add_index_field 'qwerty' }
-
-    describe '#get_field_values' do
-      it 'renders values for the given field' do
-        expect(subject.get_field_values(field_config, value: ['x', 'y'])).to eq 'x and y'
-      end
-    end
-
-    describe '#render_field_values' do
-      it 'renders values for the given field' do
-        expect(subject.render_field_values('x')).to eq 'x'
-      end
-    end
-
-    describe '#render_values' do
-      it 'renders values for the given field' do
-        expect(subject.render_values(['x', 'y', 'z'])).to eq 'x, y, and z'
-      end
-    end
-  end
 end

data/spec/presenters/pipeline_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight::Rendering::Pipeline do
+RSpec.describe Blacklight::Rendering::Pipeline do
   include Capybara::RSpecMatchers
   let(:document) { instance_double(SolrDocument) }
   let(:context) { double }
@@ -9,28 +9,35 @@ describe Blacklight::Rendering::Pipeline do
 
   describe "render" do
     subject { presenter.render }
-    let(:values) { ['a', 'b'] }
-    let(:field_config) { Blacklight::Configuration::NullField.new } 
+
+    let(:values) { %w[a b] }
+    let(:field_config) { Blacklight::Configuration::NullField.new }
+
     it { is_expected.to eq "a and b" }
 
     context "when separator_options are in the config" do
-      let(:values) { ['c', 'd'] }
-      let(:field_config) { Blacklight::Configuration::NullField.new(separator: nil, itemprop: nil, separator_options: { two_words_connector: '; '}) } 
+      let(:values) { %w[c d] }
+      let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: nil, separator_options: { two_words_connector: '; ' }) }
+
       it { is_expected.to eq "c; d" }
     end
 
     context "when itemprop is in the config" do
       let(:values) { ['a'] }
-      let(:field_config) { Blacklight::Configuration::NullField.new(separator: nil, itemprop: 'some-prop', separator_options: nil) } 
-      it { is_expected.to have_selector("span[@itemprop='some-prop']", :text => "a") }
+      let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: 'some-prop', separator_options: nil) }
+
+      it { is_expected.to have_selector("span[@itemprop='some-prop']", text: "a") }
     end
   end
 
   describe "#operations" do
     subject { described_class.operations }
-    it { is_expected.to eq [Blacklight::Rendering::HelperMethod,
-                            Blacklight::Rendering::LinkToFacet,
-                            Blacklight::Rendering::Microdata,
-                            Blacklight::Rendering::Join] }
+
+    it {
+      expect(subject).to eq [Blacklight::Rendering::HelperMethod,
+                             Blacklight::Rendering::LinkToFacet,
+                             Blacklight::Rendering::Microdata,
+                             Blacklight::Rendering::Join]
+    }
   end
 end

data/spec/presenters/thumbnail_presenter_spec.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::ThumbnailPresenter do
+  include Capybara::RSpecMatchers
+  let(:view_context) { double "View context" }
+  let(:config) { Blacklight::Configuration.new.view_config(:index) }
+  let(:presenter) { described_class.new(document, view_context, config) }
+  let(:document) { SolrDocument.new }
+
+  describe "#exists?" do
+    subject { presenter.exists? }
+
+    context "when thumbnail_method is configured" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_method: :xyz)
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context "when thumbnail_field is configured as a single field" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)
+      end
+
+      context "and the field exists in the document" do
+        let(:document) { SolrDocument.new('xyz' => 'image.png') }
+
+        it { is_expected.to be true }
+      end
+
+      context "and the field is missing from the document" do
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when thumbnail_field is configured as an array of fields" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_field: [:rst, :uvw, :xyz])
+      end
+
+      context "and the field exists in the document" do
+        let(:document) { SolrDocument.new('xyz' => 'image.png') }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when default_thumbnail is configured" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(default_thumbnail: 'image.png')
+      end
+
+      context "and the field exists in the document" do
+        it { is_expected.to be true }
+      end
+    end
+
+    context "without any configured options" do
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe "#thumbnail_tag" do
+    subject { presenter.thumbnail_tag }
+
+    context "when thumbnail_method is configured" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_method: :xyz)
+      end
+
+      context "and the method returns a value" do
+        before do
+          allow(view_context).to receive_messages(xyz: "some-thumbnail")
+        end
+
+        it "calls the provided thumbnail method" do
+          expect(view_context).to receive_messages(xyz: "some-thumbnail")
+          allow(view_context).to receive(:link_to_document).with(document, "some-thumbnail", {})
+                                                           .and_return("link")
+          expect(subject).to eq "link"
+        end
+
+        context "and url options have :suppress_link" do
+          subject { presenter.thumbnail_tag({}, suppress_link: true) }
+
+          it "does not link to the document" do
+            expect(subject).to eq "some-thumbnail"
+          end
+        end
+      end
+
+      context "and no value is returned from the thumbnail method" do
+        before do
+          allow(view_context).to receive_messages(xyz: nil)
+        end
+
+        it { is_expected.to be nil }
+      end
+    end
+
+    context "when thumbnail_field is configured" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_field: :xyz)
+      end
+
+      it "creates an image tag from the given field" do
+        allow(document).to receive(:first).with(:xyz).and_return("http://example.com/some.jpg")
+        allow(view_context).to receive(:image_tag).with("http://example.com/some.jpg", {}).and_return('<img src="image.jpg">')
+        expect(view_context).to receive(:link_to_document).with(document, '<img src="image.jpg">', {})
+        subject
+      end
+
+      it "returns nil if no thumbnail is in the document" do
+        allow(document).to receive(:first).with(:xyz).and_return(nil)
+        expect(subject).to be_nil
+      end
+    end
+
+    context "when thumbnail_field is configured as an array of fields" do
+      let(:config) do
+        Blacklight::OpenStructWithHashAccess.new(thumbnail_field: [:rst, :uvw, :xyz])
+      end
+
+      context "and the field exists in the document" do
+        let(:document) { SolrDocument.new(xyz: 'http://example.com/some.jpg') }
+
+        it "creates an image tag from the given field" do
+          allow(view_context).to receive(:image_tag).with("http://example.com/some.jpg", {}).and_return('<img src="image.jpg">')
+          expect(view_context).to receive(:link_to_document).with(document, '<img src="image.jpg">', {}).and_return('<a><img></a>')
+          expect(presenter.thumbnail_tag).to eq '<a><img></a>'
+        end
+      end
+    end
+
+    context "when default_thumbnail is configured" do
+      context "and is a string" do
+        let(:config) do
+          Blacklight::OpenStructWithHashAccess.new(default_thumbnail: 'image.png')
+        end
+
+        it "creates an image tag for the given asset" do
+          allow(view_context).to receive(:image_tag).with('image.png', {}).and_return('<img src="image.jpg">')
+          expect(presenter.thumbnail_tag({}, suppress_link: true)).to eq '<img src="image.jpg">'
+        end
+      end
+
+      context "and is a symbol" do
+        let(:config) do
+          Blacklight::OpenStructWithHashAccess.new(default_thumbnail: :get_a_default_thumbnail)
+        end
+
+        it "calls that helper method" do
+          allow(view_context).to receive(:get_a_default_thumbnail).with(document, {}).and_return('<img src="image.jpg">')
+          expect(presenter.thumbnail_tag({}, suppress_link: true)).to eq '<img src="image.jpg">'
+        end
+      end
+
+      context "and is a proc" do
+        let(:config) do
+          Blacklight::OpenStructWithHashAccess.new(default_thumbnail: ->(_, _) { '<img src="image.jpg">' })
+        end
+
+        it "calls that lambda" do
+          expect(presenter.thumbnail_tag({}, suppress_link: true)).to eq '<img src="image.jpg">'
+        end
+      end
+    end
+
+    context "when no thumbnail is configured" do
+      it { is_expected.to be_nil }
+    end
+  end
+end