blacklight 6.20.0 → 7.3.0

data/spec/controllers/saved_searches_controller_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-describe SavedSearchesController do
-  routes { Blacklight::Engine.routes }
-
-  before(:all) do
-    @one = Search.create
-    @two = Search.create
-    @three = Search.create
-  end
-
-  before(:each) do
-    @user = User.create! :email => 'test@example.com', :password => 'abcd12345', :password_confirmation => 'abcd12345'
-    sign_in @user  
-  end
-
-  describe "save" do
-    it "lets you save a search" do
-      request.env["HTTP_REFERER"] = "where_i_came_from"
-      session[:history] = [@one.id]
-      post :save, params: { id: @one.id }
-      expect(response).to redirect_to "where_i_came_from"
-    end
-
-    it "does not let you save a search that isn't in your search history" do
-      session[:history] = [@one.id]
-      expect {
-        post :save, params: { id: @two.id }
-      }.to raise_error ActiveRecord::RecordNotFound
-    end
-  end
-end

data/spec/controllers/suggest_controller_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-describe SuggestController do
-  routes { Blacklight::Engine.routes }
-  describe 'GET index' do
-    it 'returns JSON' do
-      get :index, params: { format: 'json' }
-      expect(response.body).to eq [].to_json
-    end
-    it 'returns suggestions' do
-      get :index, params: { format: 'json', q: 'new' }
-      json = JSON.parse(response.body)
-      expect(json.count).to eq 3
-      expect(json.first['term']).to eq 'new jersey'
-    end
-  end
-end

data/spec/features/saved_searches_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-describe "Saved Searches" do
-  before do
-    sign_in 'user1'
-    visit root_path
-  end
-
-  it "is empty" do
-    click_link 'Saved Searches'
-    expect(page).to have_content 'You have no saved searches'
-  end
-
-  describe "with a saved search 'book'" do
-    before do
-      fill_in "q", with: 'book'
-      click_button 'search'
-      click_link "History"
-      click_button "save"
-      click_link 'Saved Searches'
-    end
-    it "shows saved searches" do
-      expect(page).to have_content 'Your saved searches'
-      expect(page).to have_content 'book'
-    end
-    it "deletes saved searches" do
-      click_button 'delete'
-      expect(page).to have_content 'Successfully removed that saved search.'
-    end
-
-    describe "and a saved search 'dang'" do
-      before do
-        visit root_path
-        fill_in "q", with: 'dang'
-        click_button 'search'
-        click_link "History"
-        click_button "save"
-        click_link 'Saved Searches'
-      end
-      it "clears the searhes" do
-        click_link "Clear Saved Searches"
-        expect(page).to have_content 'Cleared your saved searches.'
-        expect(page).to have_content 'You have no saved searches'
-      end
-    end
-  end
-end

data/spec/helpers/deprecated_url_helper_behavior_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-describe Blacklight::DeprecatedUrlHelperBehavior do
-  around do |test|
-    Deprecation.silence(described_class) do
-      test.call
-    end
-  end
-
-  let(:parameter_class) { ActionController::Parameters }
-  let(:search_state) { Blacklight::SearchState.new(params, blacklight_config) }
-  let(:params) { parameter_class.new }
-  let(:blacklight_config) { Blacklight::Configuration.new }
-
-  before do
-    allow(helper).to receive(:search_state).and_return(search_state)
-    allow(helper).to receive(:params).and_return(params)
-    allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-    allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
-  end
-
-  describe '#params_for_search' do
-    it 'passes through to the search state' do
-      expect(helper.params_for_search).to eq search_state.params_for_search
-    end
-
-    it 'passes arguments through to the search state' do
-      expect(helper.params_for_search(merge: 1)).to eq search_state.params_for_search(merge: 1)
-    end
-
-    it 'generates a search state for the source parameters' do
-      expect(helper.params_for_search(parameter_class.new(source: 1), { merge: 1 })).to include merge: 1, source: 1
-    end
-  end
-
-  describe '#sanitize_search_params' do
-    it 'passes through to the parameter sanitizer' do
-      expect(helper.sanitize_search_params(a: 1)).to eq Blacklight::Parameters.sanitize(a: 1)
-    end
-  end
-
-  describe '#reset_search_params' do
-    let(:source_parameters) { parameter_class.new page: 1, counter: 10 }
-    it 'resets the current page and counter' do
-      expect(helper.reset_search_params(source_parameters)).to be_blank
-    end
-  end
-
-  describe '#add_facet_params' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.add_facet_params(field, item)).to eq search_state.add_facet_params(field, item)
-    end
-
-    context "with source_parameters" do
-      let(:source_parameters) { parameter_class.new source: 1 }
-      it 'generates a search state for the source parameters' do
-        expect(helper.add_facet_params(field, item, source_parameters)).to include source: 1
-      end
-    end
-  end
-
-  describe '#add_facet_params_and_redirect' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.add_facet_params_and_redirect(field, item)).to eq search_state.add_facet_params_and_redirect(field, item)
-    end
-  end
-
-  describe '#remove_facet_params' do
-    before do
-      blacklight_config.add_facet_field 'x'
-    end
-
-    let(:field) { blacklight_config.facet_fields['x'] }
-    let(:item) { true }
-
-    it 'passes through to the search state' do
-      expect(helper.remove_facet_params(field, item)).to eq search_state.remove_facet_params(field, item)
-    end
-
-    context "with source_parameters" do
-      let(:source_parameters) { parameter_class.new source: 1 }
-      it 'generates a search state for the source parameters' do
-        expect(helper.remove_facet_params(field, item, source_parameters)).to include source: 1
-      end
-    end
-  end
-end

data/spec/lib/blacklight/utils_spec.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-describe 'Blacklight::Utils' do
-  describe Blacklight::OpenStructWithHashAccess do
-    it "provides hash-like accessors for OpenStruct data" do
-      a = Blacklight::OpenStructWithHashAccess.new :foo => :bar, :baz => 1
-
-      expect(a[:foo]).to eq :bar
-      expect(a[:baz]).to eq 1
-      expect(a[:asdf]).to be_nil
-    end
-
-    it "provides hash-like writers for OpenStruct data" do
-      a = Blacklight::OpenStructWithHashAccess.new :foo => :bar, :baz => 1
-
-      a[:asdf] = 'qwerty'
-      expect(a.asdf).to eq 'qwerty'
-
-    end
-    
-    it "treats symbols and strings interchangeably in hash access" do
-      h = Blacklight::OpenStructWithHashAccess.new
-      
-      h["string"] = "value"
-      expect(h[:string]).to eq "value"
-      expect(h.string).to eq "value"
-      
-      h[:symbol] = "value"
-      expect(h["symbol"]).to eq "value"
-      expect(h.symbol).to eq "value"      
-    end
-
-    describe "internal hash table" do
-      before do
-        @h = Blacklight::OpenStructWithHashAccess.new
-        @h[:a] = 1
-        @h[:b] = 2
-      end
-
-      it "exposes the internal hash table" do
-        expect(@h.to_h).to be_a_kind_of(Hash)
-        expect(@h.to_h[:a]).to eq 1
-      end
-
-      it "exposes keys" do
-        expect(@h.keys).to include(:a, :b)
-      end
-
-    end
-
-    describe "#key?" do
-      subject do
-        h = Blacklight::OpenStructWithHashAccess.new
-        h[:a] = 1
-        h[:b] = 2
-        h
-      end
-
-      it "is true if the key exists" do
-        expect(subject.key? :a).to eq true
-      end
-      
-      it "is false if the key does not exist" do
-        expect(subject.key? :c).to eq false
-      end
-    end
-
-    describe "#replace" do
-      subject { Blacklight::OpenStructWithHashAccess.new a: 1 }
-
-      it "can use #replace to reorder the hash" do
-        subject.replace b: 1
-        expect(subject.b).to eq 1
-      end
-    end
-
-    describe "#sort_by" do
-      subject { Blacklight::OpenStructWithHashAccess.new c: 3, b:1, a: 2 }
-
-      it "sorts the underlying hash" do
-        sorted = subject.sort_by { |k,v| v }
-        expect(sorted.keys).to match_array [:b, :a, :c]
-      end
-    end
-
-    describe "#sort_by!" do
-      subject { Blacklight::OpenStructWithHashAccess.new c: 3, b:1, a: 2 }
-
-      it "sorts the underlying hash" do
-        subject.sort_by! { |k,v| v }
-        expect(subject.keys).to match_array [:b, :a, :c]
-      end
-    end
-
-    describe "#merge" do
-
-      before do
-        @h = Blacklight::OpenStructWithHashAccess.new
-        @h[:a] = 1
-        @h[:b] = 2
-      end
-      
-      it "merges the object with a hash" do
-        expect(@h.merge(:a => 'a')[:a]).to eq 'a'
-      end
-
-      it "merges the object with another struct" do
-        expect(@h.merge(Blacklight::OpenStructWithHashAccess.new(:a => 'a'))[:a]).to eq 'a'
-      end
-    end
-
-
-    describe "#merge!" do
-      
-      before do
-        @h = Blacklight::OpenStructWithHashAccess.new
-        @h[:a] = 1
-        @h[:b] = 2
-      end
-      
-      it "merges the object with a hash" do
-        @h.merge!(:a => 'a')
-        expect(@h[:a]).to eq 'a'
-      end
-
-      it "merges the object with another struct" do
-        @h.merge!(Blacklight::OpenStructWithHashAccess.new(:a => 'a'))
-        expect(@h[:a]).to eq 'a'
-      end
-    end
-
-    describe "#to_json" do
-      subject { Blacklight::OpenStructWithHashAccess.new a: 1, b: 2}
-
-      it "serializes as json" do
-        expect(subject.to_json).to eq ({a: 1, b:2}).to_json
-      end
-    end
-
-    describe "#deep_dup" do
-      subject { Blacklight::OpenStructWithHashAccess.new a: 1, b: { c: 1} }
-
-      it "duplicates nested hashes" do
-        copy = subject.deep_dup
-        copy.a = 2
-        copy.b[:c] = 2
-
-        expect(subject.a).to eq 1
-        expect(subject.b[:c]).to eq 1
-        expect(copy.a).to eq 2
-        expect(copy.b[:c]).to eq 2
-      end
-
-      it "preserves the current class" do
-        expect(Blacklight::NestedOpenStructWithHashAccess.new(Blacklight::NestedOpenStructWithHashAccess).deep_dup).to be_a_kind_of Blacklight::NestedOpenStructWithHashAccess
-      end
-
-      it "preserves the default proc" do
-        nested = Blacklight::NestedOpenStructWithHashAccess.new Hash
-
-        copy = nested.deep_dup
-        copy.a[:b] = 1
-        expect(copy.a[:b]).to eq 1
-      end
-    end
-  end
-end

data/spec/models/blacklight/solr/document/more_like_this_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-describe Blacklight::Solr::Document::MoreLikeThis do
-  before(:all) do
-    @mock_class = Class.new do
-      include Blacklight::Solr::Document
-    end
-  end
-  
-  it "should pluck the MoreLikeThis results from the Solr Response" do
-    mock_solr_response = double(:more_like => [{'id' => 'abc'}])
-    result = @mock_class.new({:id => '123'}, mock_solr_response).more_like_this
-    expect(result).to have(1).item
-    expect(result.first).to be_a_kind_of(@mock_class)
-    expect(result.first.id).to eq 'abc'
-    expect(result.first.solr_response).to eq mock_solr_response
-  end 
-end

data/spec/presenters/document_presenter_spec.rb

@@ -1,438 +0,0 @@
-# frozen_string_literal: true
-
-describe Blacklight::DocumentPresenter do
-  include Capybara::RSpecMatchers
-  let(:show_presenter) { Blacklight::ShowPresenter.new(document, request_context, config) }
-  let(:index_presenter) { Blacklight::IndexPresenter.new(document, request_context, config) }
-  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 }
-  let(:search_state) { Blacklight::SearchState.new(params, config) }
-
-  let(:document) do
-    SolrDocument.new(id: 1,
-                     'link_to_search_true' => 'x',
-                     'link_to_search_named' => 'x',
-                     'qwer' => 'document qwer value',
-                     'mnbv' => 'document mnbv value')
-  end
-
-  before do
-    allow(request_context).to receive(:search_state).and_return(search_state)
-    allow(Deprecation).to receive(:warn)
-  end
-
-  describe "link_rel_alternates" do
-    before do
-      class MockDocument
-        include Blacklight::Solr::Document
-      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
-      end
-
-      MockDocument.use_extension(MockExtension)
-
-      def mock_document_app_helper_url *args
-        solr_document_url(*args)
-      end
-
-      allow(request_context).to receive(:polymorphic_url) do |_, opts|
-        "url.#{opts[:format]}"
-      end
-      allow(request_context).to receive(:show_presenter).and_return(show_presenter)
-    end
-
-    let(:document) { MockDocument.new(id: "MOCK_ID1") }
-
-    context "with no arguments" do
-      subject { presenter.link_rel_alternates }
-
-      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|
-            expect(matches).to have(1).match
-            tag = matches[0]
-            expect(tag.attributes["rel"].value).to eq "alternate"
-            expect(tag.attributes["title"].value).to eq format.to_s
-            expect(tag.attributes["href"].value).to eq mock_document_app_helper_url(document, format: format)
-          end
-        end
-        Capybara.ignore_hidden_elements = tmp_value
-      end
-
-      it { is_expected.to be_html_safe }
-    end
-
-    context "with unique: true" do
-      subject { presenter.link_rel_alternates(unique: true) }
-
-      it "respects unique: true" do
-        tmp_value = Capybara.ignore_hidden_elements
-        Capybara.ignore_hidden_elements = false
-        expect(subject).to have_selector("link[type='application/weird']", count: 1)
-        Capybara.ignore_hidden_elements = tmp_value
-      end
-    end
-
-    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']")
-        Capybara.ignore_hidden_elements = tmp_value
-      end
-    end
-  end
-
-  describe "render_index_field_value" do
-    let(:config) 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 'link_to_search_true', :link_to_search => true
-        config.add_index_field 'link_to_search_named', :link_to_search => :some_field
-        config.add_index_field 'highlight', :highlight => true
-        config.add_index_field 'solr_doc_accessor', :accessor => true
-        config.add_index_field 'explicit_accessor', :accessor => :solr_doc_accessor
-        config.add_index_field 'explicit_accessor_with_arg', :accessor => :solr_doc_accessor_with_arg
-        config.add_index_field 'alias', field: 'qwer'
-        config.add_index_field 'with_default', default: 'value'
-      end
-    end
-    before do
-      allow(request_context).to receive(:index_presenter).and_return(index_presenter)
-    end
-    it "checks for an explicit value" do
-      value = subject.render_index_field_value 'asdf', :value => 'asdf'
-      expect(value).to eq 'asdf'
-    end
-
-    it "checks for a helper method to call" do
-      allow(request_context).to receive(:render_asdf_index_field).and_return('custom asdf value')
-      value = subject.render_index_field_value 'asdf'
-      expect(value).to eq 'custom asdf value'
-    end
-
-    it "checks for a link_to_search" do
-      allow(request_context).to receive(:search_action_path).with('f' => { 'link_to_search_true' => ['x'] }).and_return('/foo')
-      allow(request_context).to receive(:link_to).with("x", '/foo').and_return('bar')
-      value = subject.render_index_field_value 'link_to_search_true'
-      expect(value).to eq 'bar'
-    end
-
-    it "checks for a link_to_search with a field name" 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')
-      value = subject.render_index_field_value 'link_to_search_named'
-      expect(value).to eq 'bar'
-    end
-
-    context "when no highlight field is available" do
-      before do
-        allow(document).to receive(:has_highlight_field?).and_return(false)
-      end
-      let(:value) { subject.render_index_field_value 'highlight' }
-      it "is blank" do
-        expect(value).to be_blank
-      end
-    end
-
-    it "checks for a highlighted field" do
-      allow(document).to receive(:has_highlight_field?).and_return(true)
-      allow(document).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
-      value = subject.render_index_field_value 'highlight'
-      expect(value).to eq '<em>highlight</em>'
-    end
-
-    it "checks the document field value" do
-      value = subject.render_index_field_value 'qwer'
-      expect(value).to eq 'document qwer value'
-    end
-
-    it "works with index fields that aren't explicitly defined" do
-      value = subject.render_index_field_value 'mnbv'
-      expect(value).to eq 'document mnbv value'
-    end
-
-    it "calls an accessor on the solr document" do
-      allow(document).to receive_messages(solr_doc_accessor: "123")
-      value = subject.render_index_field_value 'solr_doc_accessor'
-      expect(value).to eq "123"
-    end
-
-    it "calls an explicit accessor on the solr document" do
-      allow(document).to receive_messages(solr_doc_accessor: "123")
-      value = subject.render_index_field_value 'explicit_accessor'
-      expect(value).to eq "123"
-    end
-
-    it "calls an accessor on the solr document with the field as an argument" do
-      allow(document).to receive(:solr_doc_accessor_with_arg).with('explicit_accessor_with_arg').and_return("123")
-      value = subject.render_index_field_value 'explicit_accessor_with_arg'
-      expect(value).to eq "123"
-    end
-
-    it "supports solr field configuration" do
-      value = subject.render_index_field_value 'alias'
-      expect(value).to eq "document qwer value"
-    end
-
-    it "supports default values in the field configuration" do
-      value = subject.render_index_field_value 'with_default'
-      expect(value).to eq "value"
-    end
-  end
-
-  describe "render_document_show_field_value" do
-    let(:config) 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 'highlight', :highlight => true
-        config.add_show_field 'solr_doc_accessor', :accessor => true
-        config.add_show_field 'explicit_accessor', :accessor => :solr_doc_accessor
-        config.add_show_field 'explicit_array_accessor', :accessor => [:solr_doc_accessor, :some_method]
-        config.add_show_field 'explicit_accessor_with_arg', :accessor => :solr_doc_accessor_with_arg
-      end
-    end
-
-    before do
-      allow(request_context).to receive(:show_presenter).and_return(show_presenter)
-    end
-
-    it 'html-escapes values' do
-      value = subject.render_document_show_field_value 'asdf', value: '<b>val1</b>'
-      expect(value).to eq '&lt;b&gt;val1&lt;/b&gt;'
-    end
-
-    it 'joins multivalued valued fields' do
-      value = subject.render_document_show_field_value 'asdf', value: ['<a', 'b']
-      expect(value).to eq '&lt;a and b'
-    end
-
-    it 'joins multivalued valued fields' do
-      value = subject.render_document_show_field_value 'asdf', value: ['a', 'b', 'c']
-      expect(value).to eq 'a, b, and c'
-    end
-
-    it "checks for an explicit value" do
-      expect(request_context).to_not receive(:render_asdf_document_show_field)
-      value = subject.render_document_show_field_value 'asdf', :value => 'val1'
-      expect(value).to eq 'val1'
-    end
-
-    it "checks for a helper method to call" do
-      allow(request_context).to receive(:render_asdf_document_show_field).and_return('custom asdf value')
-      value = subject.render_document_show_field_value 'asdf'
-      expect(value).to eq 'custom asdf value'
-    end
-
-    it "checks for a link_to_search" do
-      allow(request_context).to receive(:search_action_path).and_return('/foo')
-      allow(request_context).to receive(:link_to).with("x", '/foo').and_return('bar')
-      value = subject.render_document_show_field_value 'link_to_search_true'
-      expect(value).to eq 'bar'
-    end
-
-    it "checks for a link_to_search with a field name" do
-      allow(request_context).to receive(:search_action_path).and_return('/foo')
-      allow(request_context).to receive(:link_to).with("x", '/foo').and_return('bar')
-      value = subject.render_document_show_field_value 'link_to_search_named'
-      expect(value).to eq 'bar'
-    end
-
-    context "when no highlight field is available" do
-      before do
-        allow(document).to receive(:has_highlight_field?).and_return(false)
-      end
-      let(:value) { subject.render_document_show_field_value 'highlight' }
-      it "is blank" do
-        expect(value).to be_blank
-      end
-    end
-
-    it "checks for a highlighted field" do
-      allow(document).to receive(:has_highlight_field?).and_return(true)
-      allow(document).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe])
-      value = subject.render_document_show_field_value 'highlight'
-      expect(value).to eq '<em>highlight</em>'
-    end
-
-    it 'respects the HTML-safeness of multivalued highlight fields' do
-      allow(document).to receive(:has_highlight_field?).and_return(true)
-      allow(document).to receive(:highlight_field).with('highlight').and_return(['<em>highlight</em>'.html_safe, '<em>other highlight</em>'.html_safe])
-      value = subject.render_document_show_field_value 'highlight'
-      expect(value).to eq '<em>highlight</em> and <em>other highlight</em>'
-    end
-
-    it "checks the document field value" do
-      value = subject.render_document_show_field_value 'qwer'
-      expect(value).to eq 'document qwer value'
-    end
-
-    it "works with show fields that aren't explicitly defined" do
-      value = subject.render_document_show_field_value 'mnbv'
-      expect(value).to eq 'document mnbv value'
-    end
-
-    it "calls an accessor on the solr document" do
-      allow(document).to receive_messages(solr_doc_accessor: "123")
-      value = subject.render_document_show_field_value 'solr_doc_accessor'
-      expect(value).to eq "123"
-    end
-
-    it "calls an explicit accessor on the solr document" do
-      allow(document).to receive_messages(solr_doc_accessor: "123")
-      value = subject.render_document_show_field_value 'explicit_accessor'
-      expect(value).to eq "123"
-    end
-
-    it "calls an explicit array-style accessor on the solr document" do
-      allow(document).to receive_message_chain(:solr_doc_accessor, some_method: "123")
-      value = subject.render_document_show_field_value 'explicit_array_accessor'
-      expect(value).to eq "123"
-    end
-
-    it "calls an accessor on the solr document with the field as an argument" do
-      allow(document).to receive(:solr_doc_accessor_with_arg).with('explicit_accessor_with_arg').and_return("123")
-      value = subject.render_document_show_field_value 'explicit_accessor_with_arg'
-      expect(value).to eq "123"
-    end
-  end
-  describe "render_field_value" do
-    before do
-      expect(Deprecation).to receive(:warn)
-    end
-    it "joins and html-safe values" do
-      expect(subject.render_field_value(['a', 'b'])).to eq "a and b"
-    end
-
-    context "with separator_options" do
-      let(:field_config) { double(to_h: { field: 'foo', separator: nil, itemprop: nil, separator_options: { two_words_connector: '; '}}) }
-      it "uses the field_config.separator_options" do
-        expect(subject.render_field_value(['c', 'd'], field_config)).to eq "c; d"
-      end
-    end
-
-    context "with itemprop attributes" do
-      let(:field_config) { double(to_h: { field: 'bar', separator: nil, itemprop: 'some-prop', separator_options: nil }) } 
-      it "includes schema.org itemprop attributes" do
-        expect(subject.render_field_value('a', field_config)).to have_selector("span[@itemprop='some-prop']", :text => "a")
-      end
-    end
-  end
-
-  describe "#document_heading" do
-    before do
-      allow(request_context).to receive(:show_presenter).and_return(show_presenter)
-    end
-    it "falls back to an id" do
-      allow(document).to receive(:[]).with('id').and_return "xyz"
-      expect(subject.document_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(:[]).with(:x).and_return("value")
-      expect(subject.document_heading).to eq "value"
-    end
-
-    it "returns the first present value" do
-      config.show.title_field = [:x, :y]
-      allow(document).to receive(:has?).with(:x).and_return(false)
-      allow(document).to receive(:has?).with(:y).and_return(true)
-      allow(document).to receive(:[]).with(:y).and_return("value")
-      expect(subject.document_heading).to eq "value"
-    end
-  end
-
-  describe "#document_show_html_title" do
-    before do
-      allow(request_context).to receive(:show_presenter).and_return(show_presenter)
-    end
-    it "falls back to an id" do
-      allow(document).to receive(:[]).with('id').and_return "xyz"
-      expect(subject.document_show_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")
-      expect(subject.document_show_html_title).to eq "value"
-    end
-
-    it "returns the first present value" do
-      config.show.html_title_field = [:x, :y]
-      allow(document).to receive(:has?).with(:x).and_return(false)
-      allow(document).to receive(:has?).with(:y).and_return(true)
-      allow(document).to receive(:fetch).with(:y, nil).and_return("value")
-      expect(subject.document_show_html_title).to eq "value"
-    end
-  end
-
-  describe '#get_field_values' do
-    let(:field_config) { double }
-    let(:options) { double }
-    it "calls field_values" do
-      expect(Deprecation).to receive(:warn)
-      expect(presenter).to receive(:field_values).with(field_config, options)
-      presenter.get_field_values('name', field_config, options)
-    end
-  end
-
-  describe '#field_values' 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'
-      end
-
-      it "checks call the helper method with arguments" do
-        allow(request_context).to receive(:render_field_with_helper) do |*args|
-          args.first
-        end
-
-        render_options = { a: 1 }
-
-        options = subject.field_values field_config, a: 1
-
-        expect(options).to include :document, :field, :value, :config, :a
-        expect(options[:document]).to eq document
-        expect(options[:field]).to eq 'field_with_helper'
-        expect(options[:value]).to eq ['value']
-        expect(options[:config]).to eq field_config
-        expect(options[:a]).to eq 1
-      end
-    end
-  end
-
-  describe '#render_values' do
-    it 'renders field values as a string' do
-      expect(subject.render_values('x')).to eq 'x'
-      expect(subject.render_values(['x', 'y'])).to eq 'x and y'
-      expect(subject.render_values(['x', 'y', 'z'])).to eq 'x, y, and z'
-    end
-  end
-end