blacklight 7.0.0.rc1 → 7.0.0.rc2

data/spec/models/blacklight/suggest/response_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-RSpec.describe Blacklight::Suggest::Response do
-  let(:empty_response) { described_class.new({}, { q: 'hello' }, 'suggest') }
+RSpec.describe Blacklight::Suggest::Response, api: true do
+  let(:empty_response) { described_class.new({}, { q: 'hello' }, 'suggest', 'mySuggester') }
   let(:full_response) do
     described_class.new(
       {
@@ -36,7 +36,8 @@ RSpec.describe Blacklight::Suggest::Response do
       {
         q: 'new'
       },
-      'suggest'
+      'suggest',
+      'mySuggester'
     )
   end
 
@@ -45,6 +46,7 @@ RSpec.describe Blacklight::Suggest::Response do
       expect(empty_response).to be_an Blacklight::Suggest::Response
     end
   end
+
   describe '#suggestions' do
     it 'returns an array of suggestions' do
       expect(full_response.suggestions).to be_an Array
@@ -52,4 +54,4 @@ RSpec.describe Blacklight::Suggest::Response do
       expect(full_response.suggestions.first['term']).to eq 'new jersey'
     end
   end
-end
+end

data/spec/models/blacklight/suggest_search_spec.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
-RSpec.describe Blacklight::SuggestSearch do
-  let(:params) { {q: 'test'} }
-  let(:suggest_path) { 'suggest' }
-  let(:connection) { instance_double(RSolr::Client, send_and_receive: 'sent')}
-  let(:repository) { instance_double(Blacklight::Solr::Repository, connection: connection) }
-  let(:suggest_search) { described_class.new(params, repository)}
+RSpec.describe Blacklight::SuggestSearch, api: true do
+  let(:params) { { q: 'test' } }
+  let(:response) { instance_double(Blacklight::Suggest::Response) }
+  let(:repository) { instance_double(Blacklight::Solr::Repository, suggestions: response) }
+  let(:suggest_search) { described_class.new(params, repository) }
+
   describe '#suggestions' do
-    it 'returns a Blacklight::Suggest::Response' do
-      expect(suggest_search).to receive(:suggest_results).and_return([])
-      expect(suggest_search).to receive(:suggest_handler_path).and_return(suggest_path)
-      expect(suggest_search.suggestions).to be_an Blacklight::Suggest::Response
-    end
-  end
-  describe '#suggest_results' do
-    it 'calls send_and_recieve from a repository connection' do
-      expect(suggest_search).to receive(:suggest_handler_path).and_return(suggest_path)
-      expect(suggest_search.suggest_results).to eq 'sent'
+    it 'delegates to the repository' do
+      expect(repository).to receive(:suggestions).with(q: 'test').and_return(response)
+      expect(suggest_search.suggestions).to eq response
     end
   end
 end

data/spec/models/blacklight/user_spec.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-RSpec.describe "Blacklight::User" do
-
-  subject { User.create! :email => 'xyz@example.com', :password => 'xyz12345' }
+RSpec.describe "Blacklight::User", api: true do
+  subject { User.create! email: 'xyz@example.com', password: 'xyz12345' }
 
   def mock_bookmark document_id
     Bookmark.new document_id: document_id, document_type: SolrDocument.to_s
   end
-  
+
   describe "#bookmarks_for_documents" do
     before do
       subject.bookmarks << mock_bookmark(1)
       subject.bookmarks << mock_bookmark(2)
       subject.bookmarks << mock_bookmark(3)
     end
-    
+
     it "returns all the bookmarks that match the given documents" do
       bookmarks = subject.bookmarks_for_documents([SolrDocument.new(id: 1), SolrDocument.new(id: 2)])
       expect(bookmarks).to have(2).items
@@ -22,18 +21,18 @@ RSpec.describe "Blacklight::User" do
       expect(bookmarks.last.document_id).to eq "2"
     end
   end
-  
+
   describe "#document_is_bookmarked?" do
     before do
       subject.bookmarks << mock_bookmark(1)
     end
-    
+
     it "is true if the document is bookmarked" do
       expect(subject).to be_document_is_bookmarked(SolrDocument.new(id: 1))
     end
 
     it "is false if the document is not bookmarked" do
-      expect(subject).to_not be_document_is_bookmarked(SolrDocument.new(id: 2))
+      expect(subject).not_to be_document_is_bookmarked(SolrDocument.new(id: 2))
     end
   end
 
@@ -41,10 +40,9 @@ RSpec.describe "Blacklight::User" do
     before do
       subject.bookmarks << mock_bookmark(1)
     end
-    
+
     it "returns the bookmark for that document id" do
       expect(subject.existing_bookmark_for(SolrDocument.new(id: 1))).to eq subject.bookmarks.first
     end
   end
-
-end    
+end

data/spec/models/bookmark_spec.rb

@@ -1,32 +1,33 @@
 # frozen_string_literal: true
 
 RSpec.describe Bookmark do
-  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345'}
   subject do
-    b = Bookmark.new(user: user)
+    b = described_class.new(user: user)
     b.document = SolrDocument.new(id: 'u001')
     b
   end
 
+  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345' }
+
   it "is valid" do
     expect(subject).to be_valid
   end
 
   it "belongs to user" do
-    expect(Bookmark.reflect_on_association(:user)).not_to be_nil
+    expect(described_class.reflect_on_association(:user)).not_to be_nil
   end
 
   it "is valid after saving" do
     subject.save
     expect(subject).to be_valid
   end
-  
+
   describe "#document_type" do
     it "is the class of the solr document" do
       expect(subject.document_type).to eq SolrDocument
     end
   end
-  
+
   describe "#document" do
     it "is a SolrDocument with just an id field" do
       expect(subject.document).to be_a_kind_of SolrDocument

data/spec/models/record_mailer_spec.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 RSpec.describe RecordMailer do
-  before(:each) do
-    allow(RecordMailer).to receive(:default) { { :from => 'no-reply@projectblacklight.org' } }
-    SolrDocument.use_extension( Blacklight::Document::Email )
-    SolrDocument.use_extension( Blacklight::Document::Sms )
-    document = SolrDocument.new({:id=>"123456", :format=>["book"], :title_tsim => "The horn", :language_ssim => "English", :author_tsim => "Janetzky, Kurt"})
+  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)
+    document = SolrDocument.new(id: "123456", format: ["book"], title_tsim: "The horn", language_ssim: "English", author_tsim: "Janetzky, Kurt")
     @documents = [document]
   end
+
   describe "email" do
-    before(:each) do
-      details = {:to => 'test@test.com', :message => "This is my message"}
-      @email = RecordMailer.email_record(@documents,details,{:host =>'projectblacklight.org', :protocol => 'https'}) 
+    before do
+      details = { to: 'test@test.com', message: "This is my message" }
+      @email = described_class.email_record(@documents, details, host: 'projectblacklight.org', protocol: 'https')
     end
+
     it "receives the TO paramater and send the email to that address" do
       expect(@email.to).to include 'test@test.com'
     end
@@ -31,17 +33,18 @@ RSpec.describe RecordMailer do
       expect(@email.body).to match /projectblacklight.org/
     end
     it "uses https URLs when protocol is set" do
-      details = {:to => 'test@test.com', :message => "This is my message"}
-      @https_email = RecordMailer.email_record(@documents,details,{:host =>'projectblacklight.org', :protocol => 'https'})
-      expect(@https_email.body).to match %r|https://projectblacklight.org/|
+      details = { to: 'test@test.com', message: "This is my message" }
+      @https_email = described_class.email_record(@documents, details, host: 'projectblacklight.org', protocol: 'https')
+      expect(@https_email.body).to match %r{https://projectblacklight.org/}
     end
   end
-  
+
   describe "SMS" do
-    before(:each) do
-      details = {:to => '5555555555@txt.att.net'}
-      @sms = RecordMailer.sms_record(@documents,details,{:host =>'projectblacklight.org:3000'})
+    before do
+      details = { to: '5555555555@txt.att.net' }
+      @sms = described_class.sms_record(@documents, details, host: 'projectblacklight.org:3000')
     end
+
     it "creates the correct TO address for the SMS email" do
       expect(@sms.to).to include '5555555555@txt.att.net'
     end
@@ -54,13 +57,12 @@ RSpec.describe RecordMailer do
     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 /projectblacklight.org:3000/      
+      expect(@sms.body).to match /projectblacklight.org:3000/
     end
     it "uses https URL when protocol is set" do
-      details = {:to => '5555555555@txt.att.net'}
-      @https_sms = RecordMailer.sms_record(@documents,details,{:host =>'projectblacklight.org', :protocol => 'https'})
-      expect(@https_sms.body).to match %r|https://projectblacklight.org/|
+      details = { to: '5555555555@txt.att.net' }
+      @https_sms = described_class.sms_record(@documents, details, host: 'projectblacklight.org', protocol: 'https')
+      expect(@https_sms.body).to match %r{https://projectblacklight.org/}
     end
   end
-
 end

data/spec/models/search_spec.rb

@@ -1,57 +1,58 @@
 # frozen_string_literal: true
 
 RSpec.describe Search do
-  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345'}
+  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345' }
+
   describe "query_params" do
-    before(:each) do
-      @search = Search.new(user: user)
-      @query_params = { :q => "query", :f => "facet" }
+    before do
+      @search = described_class.new(user: user)
+      @query_params = { q: "query", f: "facet" }
     end
 
     it "can save and retrieve the hash" do
       @search.query_params = @query_params
       @search.save!
-      expect(Search.find(@search.id).query_params).to eq @query_params
+      expect(described_class.find(@search.id).query_params).to eq @query_params
     end
   end
 
   describe "saved?" do
     it "is true when user_id is not NULL and greater than 0" do
-      @search = Search.new(user: user)
+      @search = described_class.new(user: user)
       @search.save!
 
       expect(@search).to be_saved
     end
     it "is false when user_id is NULL or less than 1" do
-      @search = Search.create
+      @search = described_class.create
       expect(@search).not_to be_saved
     end
   end
 
   describe "delete_old_searches" do
     it "throws an ArgumentError if days_old is not a number" do
-      expect { Search.delete_old_searches("blah") }.to raise_error(ArgumentError)
+      expect { described_class.delete_old_searches("blah") }.to raise_error(ArgumentError)
     end
 
     it "throws an ArgumentError if days_old is equal to 0" do
-      expect { Search.delete_old_searches(0) }.to raise_error(ArgumentError)
+      expect { described_class.delete_old_searches(0) }.to raise_error(ArgumentError)
     end
 
     it "throws an ArgumentError if days_old is less than 0" do
-      expect { Search.delete_old_searches(-1) }.to raise_error(ArgumentError)
+      expect { described_class.delete_old_searches(-1) }.to raise_error(ArgumentError)
     end
 
     it "destroy searches with no user_id that are older than X days" do
-      Search.destroy_all
+      described_class.destroy_all
       days_old = 7
-      Search.create!(created_at: Date.today)
-      Search.create!(created_at: Date.today - (days_old + 1).days)
-      Search.create!(user: user, created_at: Date.today)
-      Search.create!(user: user, created_at: Date.today - (days_old + 1).days)
+      described_class.create!(created_at: Date.today)
+      described_class.create!(created_at: Date.today - (days_old + 1).days)
+      described_class.create!(user: user, created_at: Date.today)
+      described_class.create!(user: user, created_at: Date.today - (days_old + 1).days)
 
       expect do
-        Search.delete_old_searches(days_old)
-      end.to change(Search, :count).by(-1)
+        described_class.delete_old_searches(days_old)
+      end.to change(described_class, :count).by(-1)
     end
   end
 end

data/spec/models/solr_document_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe SolrDocument do
+RSpec.describe SolrDocument, api: true do
   describe "access methods" do
     let(:solrdoc) do
       SolrDocument.new(id: '00282214', format: ['Book'], title_tsim: 'some-title')
@@ -11,28 +11,32 @@ RSpec.describe SolrDocument do
 
       context "with title_tsim" do
         let(:field) { :title_tsim }
+
         it { is_expected.to eq 'some-title' }
       end
+
       context "with format" do
         let(:field) { :format }
+
         it { is_expected.to eq ['Book'] }
       end
     end
 
     describe "#id" do
       subject { solrdoc.id }
+
       it { is_expected.to eq '00282214' }
     end
   end
 
   describe '.attribute' do
     subject(:title) { document.title }
+
     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'
-
       end
     end
     let(:document) do

data/spec/presenters/blacklight/document_presenter_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::DocumentPresenter do
+  let(:presenter) { described_class.new }
+  let(:doc) { instance_double(SolrDocument) }
+  let(:view_context) { double('View context', should_render_field?: true) }
+
+  before do
+    allow(presenter).to receive(:document).and_return(doc)
+    allow(presenter).to receive(:view_context).and_return(view_context)
+  end
+
+  describe '#fields_to_render' do
+    subject { presenter.fields_to_render }
+
+    let(:field_config) { double(field: 'asdf') }
+
+    context 'when all of the fields have values' do
+      before do
+        allow(presenter).to receive_messages(fields: { 'title' => field_config },
+                                             render_field?: true,
+                                             has_value?: true)
+      end
+
+      it { is_expected.to eq('title' => field_config) }
+    end
+  end
+
+  describe '#render_field?' do
+    subject { presenter.send(:render_field?, field_config) }
+
+    let(:field_config) { double('field config', if: true, unless: false) }
+
+    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
+      let(:view_context) { double('View context', should_render_field?: false) }
+
+      before do
+        allow(field_config).to receive_messages(if: false)
+      end
+
+      it { is_expected.to be false }
+    end
+  end
+
+  describe '#has_value?' do
+    subject { presenter.send(:has_value?, field_config) }
+
+    context 'when the document has the field value' do
+      let(:field_config) { double(field: 'asdf') }
+
+      before do
+        allow(doc).to receive(:has?).with('asdf').and_return(true)
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context 'when the document has a highlight field value' do
+      let(:field_config) { double(field: 'asdf', highlight: true) }
+
+      before do
+        allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
+        allow(doc).to receive(:has?).with('asdf').and_return(true)
+      end
+
+      it { is_expected.to be true }
+    end
+
+    context 'when the field is a model accessor' do
+      let(:field_config) { double(field: 'asdf', highlight: true, accessor: true) }
+
+      before do
+        allow(doc).to receive(:has_highlight_field?).with('asdf').and_return(true)
+        allow(doc).to receive(:has?).with('asdf').and_return(true)
+      end
+
+      it { is_expected.to be true }
+    end
+  end
+end

data/spec/presenters/blacklight/index_presenter_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::IndexPresenter, api: true do
+  include Capybara::RSpecMatchers
+  subject { presenter }
+
+  let(:request_context) { double(document_index_view_type: 'list') }
+  let(:config) { Blacklight::Configuration.new }
+
+  let(:presenter) { described_class.new(document, request_context, config) }
+  let(:parameter_class) { ActionController::Parameters }
+  let(:params) { parameter_class.new }
+  let(:controller) { double }
+  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')
+  end
+
+  before do
+    allow(request_context).to receive(:search_state).and_return(search_state)
+  end
+
+  describe '#field_value' do
+    subject { presenter.field_value field }
+
+    let(:field) { config.index_fields[field_name] }
+    let(:field_name) { 'asdf' }
+    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_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
+        config.add_index_field 'solr_doc_accessor', accessor: true
+        config.add_index_field 'explicit_accessor', accessor: :solr_doc_accessor
+        config.add_index_field 'alias', field: 'qwer'
+        config.add_index_field 'with_default', default: 'value'
+      end
+    end
+
+    context 'when an explicit value is provided' do
+      subject { presenter.field_value field, value: 'asdf' }
+
+      it { is_expected.to eq 'asdf' }
+    end
+
+    context 'when field has a helper method' do
+      before do
+        allow(request_context).to receive(:render_asdf_index_field).and_return('custom asdf value')
+      end
+
+      it { is_expected.to eq 'custom asdf value' }
+    end
+
+    context 'when field has link_to_facet with true' do
+      before do
+        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_facet_true' }
+
+      it { is_expected.to eq 'bar' }
+    end
+
+    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_facet_named' }
+
+      it { is_expected.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(:field_name) { 'highlight' }
+
+      it { is_expected.to be_blank }
+    end
+
+    context 'when highlight field is available' do
+      before 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])
+      end
+
+      let(:field_name) { 'highlight' }
+
+      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'
+      end
+    end
+
+    context 'when accessor is true' do
+      before do
+        allow(document).to receive_messages(solr_doc_accessor: "123")
+      end
+
+      let(:field_name) { 'solr_doc_accessor' }
+
+      it { is_expected.to eq '123' }
+    end
+
+    context 'when accessor is set to a value' do
+      let(:field_name) { 'explicit_accessor' }
+
+      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'
+      end
+    end
+
+    context 'when the field is an alias' do
+      let(:field_name) { 'alias' }
+
+      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' }
+    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' }
+      let(:document) do
+        SolrDocument.new(id: 1, '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
+
+        options = subject.send(: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 '#fields' do
+    let(:field) { instance_double(Blacklight::Configuration::Field) }
+
+    before do
+      allow(config).to receive(:index_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 "#thumbnail" do
+    subject { presenter.thumbnail }
+
+    it { is_expected.to be_instance_of Blacklight::ThumbnailPresenter }
+  end
+end