blacklight 6.21.0 → 7.3.0

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

@@ -43,9 +43,10 @@ RSpec.describe Blacklight::Suggest::Response, api: true do
 
   describe '#initialize' do
     it 'creates a Blacklight::Suggest::Response' do
-      expect(empty_response).to be_an Blacklight::Suggest::Response
+      expect(empty_response).to be_an described_class
     end
   end
+
   describe '#suggestions' do
     it 'returns an array of suggestions' do
       expect(full_response.suggestions).to be_an Array

data/spec/models/blacklight/suggest_search_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-describe Blacklight::SuggestSearch do
-  let(:params) { {q: 'test'} }
-  let(:response) { instance_double(Blacklight::Suggest::Response)}
+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)}
+  let(:suggest_search) { described_class.new(params, repository) }
 
   describe '#suggestions' do
     it 'delegates to the repository' do

data/spec/models/blacklight/user_spec.rb

@@ -1,20 +1,19 @@
 # frozen_string_literal: true
 
-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 @@ 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 @@ 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
 
-describe Bookmark do
-  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345'}
+RSpec.describe Bookmark do
   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
 
-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_display => "The horn", :language_facet => "English", :author_display => "Janetzky, Kurt"})
+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)
+    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 @@ 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 @@ 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
 
-describe Search do
-  let(:user) { User.create! email: 'xyz@example.com', password: 'xyz12345'}
+RSpec.describe Search do
+  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,27 +1,55 @@
 # 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_display: 'some-title')
+      described_class.new(id: '00282214', format: ['Book'], title_tsim: 'some-title')
     end
 
     describe "#[]" do
       subject { solrdoc[field] }
 
-      context "with title_display" do
-        let(:field) { :title_display }
+      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
+      doc_class.new(id: '123',
+                    title_tesim: ['Good Omens'],
+                    author_tesim: ['Neil Gaiman', 'Terry Pratchett'],
+                    date_dtsi: '1990-01-01T00:00:00Z')
+    end
+
+    it "casts the attributes" do
+      expect(document.title).to eq 'Good Omens'
+      expect(document.author).to eq ['Neil Gaiman', 'Terry Pratchett']
+      expect(document.date).to eq Date.new(1990)
+    end
+  end
 end

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/{index_presenter_spec.rb → blacklight/index_presenter_spec.rb}

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-describe Blacklight::IndexPresenter do
+RSpec.describe Blacklight::IndexPresenter, api: true do
   include Capybara::RSpecMatchers
-  let(:request_context) { double }
+  subject { presenter }
+
+  let(:request_context) { double(document_index_view_type: 'list') }
   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::IndexPresenter 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
 
@@ -32,8 +33,8 @@ describe Blacklight::IndexPresenter 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 '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
@@ -42,33 +43,6 @@ describe Blacklight::IndexPresenter 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
-
-      context 'with a name as a symbol' 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 'with a name as an integer' do
-        subject { presenter.field_value 123 }
-
-        it 'raises a deprecation' do
-          expect(Deprecation).to receive(:warn)
-          expect(subject).to eq ''
-        end
-      end
-    end
-
     context 'when an explicit value is provided' do
       subject { presenter.field_value field, value: 'asdf' }
 
@@ -83,24 +57,24 @@ describe Blacklight::IndexPresenter 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
@@ -171,9 +145,8 @@ describe Blacklight::IndexPresenter 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
@@ -181,8 +154,6 @@ describe Blacklight::IndexPresenter 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
@@ -195,29 +166,21 @@ describe Blacklight::IndexPresenter do
     end
   end
 
-  describe 'deprecated methods' do
+  describe '#fields' do
+    let(:field) { instance_double(Blacklight::Configuration::Field) }
+
     before do
-      allow(Deprecation).to receive(:warn)
+      allow(config).to receive(:index_fields_for).and_return(title: field)
     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
+    it 'returns the list from the configs' do
+      expect(subject.send(:fields)).to eq(title: field)
     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 "#thumbnail" do
+    subject { presenter.thumbnail }
 
-    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
+    it { is_expected.to be_instance_of Blacklight::ThumbnailPresenter }
   end
 end