blacklight 7.33.0 → 8.0.0

data/spec/models/record_mailer_spec.rb

@@ -2,7 +2,16 @@
 
 RSpec.describe RecordMailer do
   let(:config) do
-    Blacklight::Configuration.new
+    Blacklight::Configuration.new do |config|
+      config.email.title_field = 'title_tsim'
+      config.add_email_field 'title_tsim', label: 'Title'
+      config.add_email_field "author_tsim", label: 'Author'
+      config.add_email_field "language_ssim", label: 'Language'
+      config.add_email_field "format", label: 'Format'
+
+      config.add_sms_field 'title_tsim', label: 'Title'
+      config.add_sms_field "author_tsim", label: 'Author'
+    end
   end
 
   let(:document) do
@@ -11,37 +20,38 @@ RSpec.describe RecordMailer do
 
   before do
     allow(described_class).to receive(:default).and_return(from: 'no-reply@projectblacklight.org')
-    SolrDocument.use_extension(Blacklight::Document::Email)
-    SolrDocument.use_extension(Blacklight::Document::Sms)
     @documents = [document]
   end
 
   describe "email" do
-    before do
-      details = { to: 'test@test.com', message: "This is my message", config: config }
-      @email = described_class.email_record(@documents, details, host: 'projectblacklight.org', protocol: 'https')
+    subject(:email) do
+      described_class.email_record(@documents, details, host: 'projectblacklight.org', protocol: 'https')
+    end
+
+    let(:details) do
+      { to: 'test@test.com', message: "This is my message", config: config }
     end
 
     it "receives the TO paramater and send the email to that address" do
-      expect(@email.to).to include 'test@test.com'
+      expect(email.to).to include 'test@test.com'
     end
 
     it "starts the subject w/ Item Record:" do
-      expect(@email.subject).to match /^Item Record:/
+      expect(email.subject).to match /^Item Record:/
     end
 
     it "puts the title of the item in the subject" do
-      expect(@email.subject).to match /The horn/
+      expect(email.subject).to match /The horn/
     end
 
     it "has the correct from address (w/o the port number)" do
-      expect(@email.from).to include "no-reply@projectblacklight.org"
+      expect(email.from).to include "no-reply@projectblacklight.org"
     end
 
     it "prints out the correct body" do
-      expect(@email.body).to match /Title: The horn/
-      expect(@email.body).to match /Author: Janetzky, Kurt/
-      expect(@email.body).to match /projectblacklight.org/
+      expect(email.body).to match /Title: The horn/
+      expect(email.body).to match /Author: Janetzky, Kurt/
+      expect(email.body).to match /projectblacklight.org/
     end
 
     it "uses https URLs when protocol is set" do
@@ -53,28 +63,31 @@ RSpec.describe RecordMailer do
     context "email title_field is configured and multi valued" do
       let(:document) { SolrDocument.new(id: "123456", foo: ["Fizz Fizz", "Fuzz Fuzz"], format: ["book"], title_tsim: "The horn", language_ssim: "English", author_tsim: "Janetzky, Kurt") }
 
-      it "uses configured email title_field" do
+      before do
         config.email.title_field = "foo"
-        expect(@email.subject).to match("Fizz Fizz")
-        expect(@email.subject).not_to match("Fuzz Fuzz")
-        expect(@email.subject).not_to match("The horn")
+      end
+
+      it "uses configured email title_field" do
+        expect(email.subject).to eq 'Item Record: Fizz Fizz and Fuzz Fuzz'
       end
     end
 
     context "email title_field is configured and single valued" do
       let(:document) { SolrDocument.new(id: "123456", foo: "Fizz Fizz", format: ["book"], title_tsim: "The horn", language_ssim: "English", author_tsim: "Janetzky, Kurt") }
 
-      it "uses configured email title_field" do
+      before do
         config.email.title_field = "foo"
-        expect(@email.subject).to match("Fizz Fizz")
-        expect(@email.subject).not_to match("The horn")
+      end
+
+      it "uses configured email title_field" do
+        expect(email.subject).to eq 'Item Record: Fizz Fizz'
       end
     end
   end
 
   describe "SMS" do
     before do
-      details = { to: '5555555555@txt.att.net' }
+      details = { to: '5555555555@txt.att.net', config: config }
       @sms = described_class.sms_record(@documents, details, host: 'projectblacklight.org:3000')
     end
 
@@ -91,8 +104,8 @@ RSpec.describe RecordMailer do
     end
 
     it "prints out the correct body" do
-      expect(@sms.body).to match /The horn/
-      expect(@sms.body).to match /by Janetzky, Kurt/
+      expect(@sms.body).to match /Title: The horn/
+      expect(@sms.body).to match /Author: Janetzky, Kurt/
       expect(@sms.body).to match /projectblacklight.org:3000/
     end
 

data/spec/models/solr_document_spec.rb

@@ -45,9 +45,11 @@ RSpec.describe SolrDocument, api: true do
 
     let(:doc_class) do
       Class.new(SolrDocument) do
-        attribute :title, Blacklight::Types::String, 'title_tesim'
-        attribute :author, Blacklight::Types::Array, 'author_tesim'
-        attribute :date, Blacklight::Types::Date, 'date_dtsi'
+        attribute :title, :string, 'title_tesim'
+        attribute :author, :array, 'author_tesim', of: :string
+        attribute :first_author, :select, 'author_tesim', by: :min
+        attribute :date, :date, field: 'date_dtsi'
+        attribute :whatever, :string, default: ->(*) { 'default_value' }
       end
     end
     let(:document) do
@@ -60,7 +62,23 @@ RSpec.describe SolrDocument, api: true do
     it "casts the attributes" do
       expect(document.title).to eq 'Good Omens'
       expect(document.author).to eq ['Neil Gaiman', 'Terry Pratchett']
+      expect(document.first_author).to eq 'Neil Gaiman'
       expect(document.date).to eq Date.new(1990)
+      expect(document.whatever).to eq 'default_value'
+    end
+
+    context 'with missing data' do
+      let(:document) { doc_class.new(id: '123') }
+
+      it 'returns nil for scalar values' do
+        expect(document.title).to be_nil
+        expect(document.first_author).to be_nil
+        expect(document.date).to be_nil
+      end
+
+      it 'returns an array for array values' do
+        expect(document.author).to eq []
+      end
     end
   end
 end

data/spec/presenters/blacklight/clause_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::ClausePresenter, type: :presenter do

data/spec/presenters/blacklight/document_presenter_spec.rb

@@ -12,12 +12,13 @@ RSpec.describe Blacklight::DocumentPresenter do
 
   before do
     allow(request_context).to receive(:search_state).and_return(search_state)
+    allow(request_context).to receive(:action_name).and_return(:show)
   end
 
   describe '#fields_to_render' do
     subject { presenter.fields_to_render.to_a }
 
-    let(:field_config) { Blacklight::Configuration::Field.new(field: 'asdf') }
+    let(:field_config) { Blacklight::Configuration::DisplayField.new(field: 'asdf') }
 
     context 'when all of the fields have values' do
       before do
@@ -30,7 +31,7 @@ RSpec.describe Blacklight::DocumentPresenter do
 
   describe '#field_value' do
     let(:field_presenter) { instance_double(Blacklight::FieldPresenter, render: 'xyz') }
-    let(:field_config) { Blacklight::Configuration::Field.new }
+    let(:field_config) { Blacklight::Configuration::DisplayField.new }
     let(:options) { { a: 1 } }
 
     it 'calls the field presenter' do

data/spec/presenters/blacklight/facet_field_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
@@ -44,11 +45,11 @@ RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
   describe '#active?' do
     it "checks if any value is selected for a given facet" do
       search_state.params[:f] = ActiveSupport::HashWithIndifferentAccess.new(key: [1])
-      expect(presenter.active?).to eq true
+      expect(presenter.active?).to be true
     end
 
     it "is false if no value for facet is selected" do
-      expect(presenter.active?).to eq false
+      expect(presenter.active?).to be false
     end
   end
 
@@ -59,12 +60,12 @@ RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
       end
 
       it 'is true' do
-        expect(presenter.in_modal?).to eq true
+        expect(presenter.in_modal?).to be true
       end
     end
 
     it 'is false' do
-      expect(presenter.in_modal?).to eq false
+      expect(presenter.in_modal?).to be false
     end
   end
 
@@ -72,7 +73,9 @@ RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
     let(:paginator) { Blacklight::FacetPaginator.new([{}, {}], limit: 1) }
 
     before do
-      allow(view_context).to receive(:facet_paginator).and_return(paginator)
+      # rubocop:disable RSpec/SubjectStub
+      allow(presenter).to receive(:paginator).and_return(paginator)
+      # rubocop:enable RSpec/SubjectStub
     end
 
     context 'with no additional data' do
@@ -97,13 +100,6 @@ RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
     end
   end
 
-  describe '#html_id' do
-    it 'gets the id from a helper' do
-      allow(view_context).to receive(:html_id).with('key').and_return('facet-key')
-      expect(presenter.html_id).to eq 'facet-key'
-    end
-  end
-
   describe '#paginator' do
     subject(:paginator) { presenter.paginator }
 
@@ -112,4 +108,81 @@ RSpec.describe Blacklight::FacetFieldPresenter, type: :presenter do
       expect(paginator.total_count).to eq 0
     end
   end
+
+  describe "#facet_limit" do
+    subject(:facet_limit) { presenter.facet_limit }
+
+    let(:search_state) { Blacklight::SearchState.new({}, blacklight_config, controller) }
+    let(:blacklight_config) { CatalogController.blacklight_config }
+    let(:facet_field) { blacklight_config.facet_fields['subject_ssim'] }
+    let(:display_facet) do
+      instance_double(Blacklight::Solr::Response::Facets::FacetField, items: items, limit: nil, sort: :index, offset: 0, prefix: nil)
+    end
+    # let(:facet_field) { Blacklight::Configuration::FacetField.new(key: 'key') }
+    # let(:display_facet) do
+    #   instance_double(Blacklight::Solr::Response::Facets::FacetField, items: items, sort: :index, offset: 0, prefix: nil)
+    # end
+
+    it "returns specified value for facet_field specified" do
+      expect(facet_limit).to eq facet_field.limit
+    end
+
+    describe "for 'true' configured values" do
+      let(:blacklight_config) do
+        Blacklight::Configuration.new do |config|
+          config.add_facet_field "language_facet", limit: true
+        end
+      end
+      let(:facet_field) { blacklight_config.facet_fields['language_facet'] }
+
+      context 'when the limit in the response is nil' do
+        let(:display_facet) do
+          instance_double(Blacklight::Solr::Response::Facets::FacetField, items: items, limit: nil, sort: :index, offset: 0, prefix: nil)
+        end
+
+        it "uses the config setting" do
+          blacklight_config.facet_fields['language_facet'].limit = 10
+          expect(facet_limit).to eq 10
+        end
+      end
+
+      context 'when the limit in the response is provided' do
+        let(:display_facet) do
+          instance_double(Blacklight::Solr::Response::Facets::FacetField, items: items, limit: 16, sort: :index, offset: 0, prefix: nil)
+        end
+
+        it "gets the limit from the facet field in @response" do
+          expect(facet_limit).to eq 15
+        end
+      end
+
+      context 'when not in the display_facet' do
+        let(:display_facet) { nil }
+
+        it "defaults to 10" do
+          expect(facet_limit).to eq 10
+        end
+      end
+    end
+
+    context 'for facet fields with a key that is different from the field name' do
+      before do
+        allow(controller).to receive(:blacklight_config).and_return(blacklight_config)
+      end
+
+      let(:blacklight_config) do
+        Blacklight::Configuration.new do |config|
+          config.add_facet_field 'some_key', field: 'x', limit: true
+        end
+      end
+      let(:facet_field) { blacklight_config.facet_fields['some_key'] }
+      let(:display_facet) do
+        instance_double(Blacklight::Solr::Response::Facets::FacetField, items: items, limit: 16, sort: :index, offset: 0, prefix: nil)
+      end
+
+      it 'gets the limit from the facet field in the @response' do
+        expect(facet_limit).to eq 15
+      end
+    end
+  end
 end

data/spec/presenters/blacklight/facet_grouped_item_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::FacetGroupedItemPresenter, type: :presenter do

data/spec/presenters/blacklight/facet_item_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
@@ -7,22 +8,22 @@ RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
   end
 
   let(:facet_item) { instance_double(Blacklight::Solr::Response::Facets::FacetItem) }
+  let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: true) }
   let(:facet_config) { Blacklight::Configuration::FacetField.new(key: 'key') }
   let(:facet_field) { instance_double(Blacklight::Solr::Response::Facets::FacetField) }
   let(:view_context) { controller.view_context }
-  let(:search_state) { instance_double(Blacklight::SearchState) }
+  let(:search_state) { instance_double(Blacklight::SearchState, filter: filter_field) }
 
   describe '#selected?' do
-    it 'works' do
-      allow(search_state).to receive(:has_facet?).and_return(true)
-      expect(presenter.selected?).to be true
-    end
+    subject { presenter.selected? }
+
+    it { is_expected.to be true }
   end
 
   describe '#label' do
-    it "is the facet value for an ordinary facet" do
+    it "is the stringified facet value for an ordinary facet" do
       allow(facet_config).to receive_messages(query: nil, date: nil, helper_method: nil, url_method: nil)
-      expect(presenter.label).to eq facet_item
+      expect(presenter.label).to eq facet_item.to_s
     end
 
     it "allows you to pass in a :helper_method argument to the configuration" do
@@ -63,9 +64,7 @@ RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
   end
 
   describe '#href' do
-    before do
-      allow(search_state).to receive(:has_facet?).and_return(false)
-    end
+    let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: false) }
 
     it 'is the url to apply the facet' do
       allow(search_state).to receive(:add_facet_params_and_redirect).with('key', facet_item).and_return(f: 'x')
@@ -87,11 +86,13 @@ RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
     end
 
     context 'with a selected facet' do
-      it 'is the url to remove the facet' do
-        allow(search_state).to receive(:has_facet?).and_return(true)
-        allow(search_state).to receive(:remove_facet_params).with('key', facet_item).and_return({})
+      let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: true, remove: {}) }
+
+      before do
         allow(view_context).to receive(:search_action_path).with({}).and_return('/catalog')
+      end
 
+      it 'is the url to remove the facet' do
         expect(presenter.href).to eq '/catalog'
       end
     end

data/spec/presenters/blacklight/field_presenter_spec.rb

@@ -36,7 +36,6 @@ RSpec.describe Blacklight::FieldPresenter, api: true do
       config.add_index_field 'solr_doc_accessor', accessor: true
       config.add_index_field 'explicit_accessor', accessor: :solr_doc_accessor
       config.add_index_field 'explicit_array_accessor', accessor: [:solr_doc_accessor, :some_method]
-      config.add_index_field 'explicit_values', values: ->(_config, _doc) { ['some-value'] }
       config.add_index_field 'explicit_values_with_context', values: ->(_config, _doc, view_context) { [view_context.params[:x]] }
       config.add_index_field 'alias', field: 'qwer'
       config.add_index_field 'with_default', default: 'value'
@@ -52,13 +51,13 @@ RSpec.describe Blacklight::FieldPresenter, api: true do
     context 'when an explicit html value is provided' do
       let(:options) { { value: '<b>val1</b>' } }
 
-      it { is_expected.to eq '&lt;b&gt;val1&lt;/b&gt;' }
+      it { is_expected.not_to be_html_safe }
     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' }
+      it { is_expected.to eq('&lt;a and b').and be_html_safe }
     end
 
     context 'when an explicit array value is provided' do
@@ -162,15 +161,6 @@ RSpec.describe Blacklight::FieldPresenter, api: true do
       end
     end
 
-    context 'when the values lambda is provided' do
-      let(:field_name) { 'explicit_values' }
-
-      it 'calls the accessors on the return of the preceeding' do
-        allow(Deprecation).to receive(:warn)
-        expect(subject).to eq 'some-value'
-      end
-    end
-
     context 'when the values lambda is provided and accepts the view contexts' do
       let(:field_name) { 'explicit_values_with_context' }
 
@@ -241,10 +231,6 @@ RSpec.describe Blacklight::FieldPresenter, api: true do
 
     let(:field_config) { double('field config', if: true, unless: false, except_operations: nil) }
 
-    before do
-      allow(presenter).to receive_messages(document_has_value?: true)
-    end
-
     it { is_expected.to be true }
 
     context 'when the view context says not to render the field' do

data/spec/presenters/blacklight/index_presenter_spec.rb

@@ -22,17 +22,16 @@ RSpec.describe Blacklight::IndexPresenter, api: true do
 
   before do
     allow(request_context).to receive(:search_state).and_return(search_state)
+    allow(request_context).to receive(:action_name).and_return(:index)
   end
 
   describe '#fields' do
-    let(:field) { instance_double(Blacklight::Configuration::Field) }
-
     before do
-      allow(config).to receive(:index_fields_for).and_return(title: field)
+      config.add_index_field 'title'
     end
 
     it 'returns the list from the configs' do
-      expect(subject.send(:fields)).to eq(title: field)
+      expect(subject.send(:fields).keys).to eq ['title']
     end
   end
 

data/spec/presenters/blacklight/json_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::JsonPresenter, api: true do

data/spec/presenters/blacklight/link_alternate_presenter_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Blacklight::LinkAlternatePresenter do
@@ -25,8 +26,8 @@ RSpec.describe Blacklight::LinkAlternatePresenter do
 
     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" />'
+        '<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 }

data/spec/presenters/blacklight/show_presenter_spec.rb

@@ -14,14 +14,12 @@ RSpec.describe Blacklight::ShowPresenter, api: true do
   let(:search_state) { Blacklight::SearchState.new(params, config, controller) }
 
   let(:document) do
-    SolrDocument.new(id: 1,
-                     'link_to_facet_true' => 'x',
-                     'link_to_facet_named' => 'x',
-                     'qwer' => 'document qwer value')
+    SolrDocument.new(id: 'xyz', some_field: 'value')
   end
 
   before do
     allow(request_context).to receive(:search_state).and_return(search_state)
+    allow(request_context).to receive(:action_name).and_return(:show)
   end
 
   describe "link_rel_alternates" do
@@ -108,43 +106,36 @@ RSpec.describe Blacklight::ShowPresenter, api: true do
   end
 
   describe '#fields' do
-    let(:field) { instance_double(Blacklight::Configuration::Field) }
-
     before do
-      allow(config).to receive(:show_fields_for).and_return(title: field)
+      config.add_show_field 'title'
     end
 
     it 'returns the list from the configs' do
-      expect(subject.send(:fields)).to eq(title: field)
+      expect(subject.send(:fields).keys).to eq ['title']
     end
   end
 
   describe "#heading" do
     it "falls back to an id" do
-      allow(document).to receive(:[]).with('id').and_return "xyz"
       expect(subject.heading).to eq document.id
     end
 
     it "returns the value of the field" do
-      config.show.title_field = :x
-      allow(document).to receive(:has?).with(:x).and_return(true)
-      allow(document).to receive(:fetch).with(:x, nil).and_return("value")
+      config.show.title_field = 'some_field'
       expect(subject.heading).to eq "value"
     end
 
     it "returns the first present value" do
-      config.show.title_field = [:x, :y]
-      allow(document).to receive(:fetch).with(:x, nil).and_return(nil)
-      allow(document).to receive(:fetch).with(:y, nil).and_return("value")
+      config.show.title_field = %w[a_field_that_doesnt_exist some_field]
       expect(subject.heading).to eq "value"
     end
 
     it "can use explicit field configuration" do
-      config.show.title_field = Blacklight::Configuration::Field.new(field: 'x', values: ->(*_) { 'hardcoded' })
+      config.show.title_field = Blacklight::Configuration::DisplayField.new(field: 'x', values: ->(*_) { 'hardcoded' })
       expect(subject.heading).to eq 'hardcoded'
     end
 
-    context "when empty document" do
+    context "with an empty document" do
       let(:document) { SolrDocument.new({}) }
 
       it "returns an empty string as the heading" do
@@ -155,26 +146,21 @@ RSpec.describe Blacklight::ShowPresenter, api: true do
 
   describe "#html_title" do
     it "falls back to an id" do
-      allow(document).to receive(:[]).with('id').and_return "xyz"
       expect(subject.html_title).to eq document.id
     end
 
     it "returns the value of the field" do
-      config.show.html_title_field = :x
-      allow(document).to receive(:has?).with(:x).and_return(true)
-      allow(document).to receive(:fetch).with(:x, nil).and_return("value")
+      config.show.html_title_field = 'some_field'
       expect(subject.html_title).to eq "value"
     end
 
     it "returns the first present value" do
-      config.show.html_title_field = [:x, :y]
-      allow(document).to receive(:fetch).with(:x, nil).and_return(nil)
-      allow(document).to receive(:fetch).with(:y, nil).and_return("value")
+      config.show.html_title_field = %w[a_field_that_doesnt_exist some_field]
       expect(subject.html_title).to eq "value"
     end
 
     it "can use explicit field configuration" do
-      config.show.html_title_field = Blacklight::Configuration::Field.new(field: 'x', values: ->(*_) { 'hardcoded' })
+      config.show.html_title_field = Blacklight::Configuration::DisplayField.new(field: 'x', values: ->(*_) { 'hardcoded' })
       expect(subject.html_title).to eq 'hardcoded'
     end
   end

data/spec/presenters/pipeline_spec.rb

@@ -4,10 +4,10 @@ RSpec.describe Blacklight::Rendering::Pipeline do
   include Capybara::RSpecMatchers
   let(:document) { instance_double(SolrDocument) }
   let(:context) { double }
-  let(:options) { double('options') }
+  let(:options) { {} }
 
   describe '.render' do
-    subject { described_class.render(values, field_config, document, context, options) }
+    subject(:rendered) { described_class.render(values, field_config, document, context, options) }
 
     let(:values) { %w[a b] }
     let(:field_config) { Blacklight::Configuration::NullField.new }
@@ -35,6 +35,17 @@ RSpec.describe Blacklight::Rendering::Pipeline do
       expect(described_class).to have_received(:new)
         .with(values, field_config, document, context, described_class.operations, options)
     end
+
+    context 'outside of an HTML context' do
+      let(:options) { { format: 'text' } }
+
+      let(:values) { ['"blah"', "<notatag>"] }
+      let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+
+      it 'does not HTML escape values or inject HTML tags' do
+        expect(rendered).to eq '"blah" and <notatag>'
+      end
+    end
   end
 
   describe '.operations' do

data/spec/presenters/thumbnail_presenter_spec.rb

@@ -95,7 +95,7 @@ RSpec.describe Blacklight::ThumbnailPresenter do
           allow(view_context).to receive_messages(xyz: nil)
         end
 
-        it { is_expected.to be nil }
+        it { is_expected.to be_nil }
       end
     end
 

data/spec/requests/load_suggestions_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'GET /catalog/suggest' do
+  it 'returns suggestions' do
+    get '/catalog/suggest?q=new'
+    expect(response.body).to eq <<-RESULT
+  <li role="option"><span>new jersey</span></li>
+  <li role="option"><span>new jersey bridgeton biography</span></li>
+  <li role="option"><span>new jersey bridgeton history</span></li>
+  <li role="option"><span>new york</span></li>
+  <li role="option"><span>nuwākshūṭ</span></li>
+    RESULT
+  end
+end