blacklight-spotlight 3.0.0.rc2 → 3.0.0

data/spec/models/spotlight/group_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+describe Spotlight::Group, type: :model do
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+
+  describe '#searches' do
+    let(:group) { FactoryBot.create(:group_with_searches, exhibit: exhibit, searches_count: 4) }
+
+    it do
+      expect(group.searches.count).to eq 4
+    end
+
+    it do
+      group.searches.all do |search|
+        expect(search).to be_an Spotlight::Search
+      end
+    end
+  end
+end

data/spec/models/spotlight/resource_spec.rb

@@ -1,126 +1,128 @@
 # frozen_string_literal: true
 
 describe Spotlight::Resource, type: :model do
-  before do
-    allow_any_instance_of(described_class).to receive(:update_index)
-  end
+  subject(:resource) { described_class.create(id: 123, exhibit: exhibit) }
 
   let(:exhibit) { FactoryBot.create(:exhibit) }
 
-  describe '#reindex' do
-    context 'with a provider that generates ids' do
-      subject do
-        Class.new(described_class).new(exhibit: exhibit)
-      end
-
-      let(:solr_response) { { id: 123 } }
-
-      before do
-        SolrDocument.new(id: 123).sidecars.create!(exhibit: exhibit, data: { document_data: true })
-        allow(subject).to receive_messages(to_global_id: '')
+  describe '#save_and_index' do
+    before do
+      allow(subject).to receive(:save)
+      allow(subject).to receive(:reindex_later)
+    end
 
-        allow(subject.document_builder).to receive(:to_solr).and_return(solr_response)
-      end
+    it 'saves the object' do
+      expect(subject).to receive(:save).and_return(true)
+      subject.save_and_index
+    end
 
-      it 'includes exhibit document-specific data' do
-        allow(subject.send(:blacklight_solr)).to receive(:update) do |options|
-          data = JSON.parse(options[:data], symbolize_names: true)
+    it 'reindexes after save' do
+      expect(subject).to receive(:save).and_return(true)
+      expect(subject).to receive(:reindex_later)
+      subject.save_and_index
+    end
 
-          expect(data.length).to eq 1
-          doc = data.first
+    it 'passes through reindexing options' do
+      expect(subject).to receive(:save).and_return(true)
+      expect(subject).to receive(:reindex_later).with(a: 1)
+      subject.save_and_index(reindex_options: { a: 1 })
+    end
 
-          break if doc.first == :commit
+    context 'if the save fails' do
+      it 'does not reindex' do
+        expect(subject).to receive(:save).and_return(false)
+        expect(subject).not_to receive(:reindex_later)
+        subject.save_and_index
+      end
+    end
+  end
 
-          expect(doc).to include document_data: true
-        end
+  describe '#reindex_later' do
+    around do |block|
+      old = ActiveJob::Base.queue_adapter
+      begin
+        ActiveJob::Base.queue_adapter = :test
 
-        subject.reindex
+        block.call
+      ensure
+        ActiveJob::Base.queue_adapter = old
       end
+    end
 
-      context 'when a document does not have an identifier' do
-        let(:solr_response) { { other_field: 'Content' } }
+    it 'passes through reindexing options' do
+      expect { subject.reindex_later(whatever: true) }.to have_enqueued_job(Spotlight::ReindexJob).with(subject, whatever: true, 'validity_token' => nil)
+    end
+  end
 
-        it 'is not indexed (but a commit can be sent)' do
-          allow(subject.send(:blacklight_solr)).to receive(:commit)
-          expect(subject.send(:blacklight_solr)).not_to receive(:update)
+  describe '#reindex' do
+    before do
+      # sneak some data into the pipeline
+      subject.indexing_pipeline.transforms = [->(*) { { id: '123' } }] + subject.indexing_pipeline.transforms
+    end
 
-          subject.reindex
-        end
-      end
+    let(:indexed_document) do
+      result = nil
 
-      context 'reindexing_log_entry is provided' do
-        before do
-          allow(subject.send(:blacklight_solr)).to receive(:update)
-        end
+      subject.reindex(**index_args) do |data, *|
+        result = data
 
-        it 'updates the count of reindexed items in the log entry' do
-          reindexing_log_entry = double(Spotlight::ReindexingLogEntry)
-          expect(reindexing_log_entry).to receive(:update).with(items_reindexed_count: 1)
-          subject.reindex reindexing_log_entry
-        end
+        # skip actually indexing the document into the solr index
+        throw :skip
       end
 
-      context 'when the index is not writable' do
-        before do
-          allow(Spotlight::Engine.config).to receive_messages(writable_index: false)
-        end
+      result
+    end
 
-        it "doesn't write" do
-          expect(subject.send(:blacklight_solr)).not_to receive(:update)
-          subject.reindex
-        end
-      end
+    let(:index_args) { {} }
+
+    it 'returns the number of items indexed' do
+      expect(subject.reindex { |*| throw :skip }).to eq 1
+    end
 
-      context 'with a resource that creates multiple solr documents' do
-        let(:solr_response) { [{ id: 1 }, { id: 2 }] }
+    it 'applies exhibit-specific metadata from the sidecar' do
+      expect(indexed_document).to include Spotlight::SolrDocumentSidecar.new(document: SolrDocument.new(id: '123'), exhibit: exhibit).to_solr
+    end
 
-        before do
-          allow(subject.send(:blacklight_solr)).to receive(:update)
-        end
+    it 'includes metata from each sidecar' do
+      a = Spotlight::SolrDocumentSidecar.create(document: SolrDocument.new(id: '123'), exhibit: exhibit)
+      b = Spotlight::SolrDocumentSidecar.create(document: SolrDocument.new(id: '123'), exhibit: FactoryBot.build(:exhibit))
 
-        it 'returns the number of indexed objects' do
-          expect(subject.reindex).to eq 2
-        end
+      expect(indexed_document).to include(a.to_solr).and(include(b.to_solr))
+    end
 
-        it 'triggers a solr commit' do
-          expect(subject.send(:blacklight_solr)).to receive(:commit).once
+    it 'persists a sidecar document' do
+      expect { indexed_document }.to change(Spotlight::SolrDocumentSidecar, :count).by(1)
 
-          subject.reindex
-        end
+      expect(Spotlight::SolrDocumentSidecar.last).to have_attributes(document_id: '123', exhibit: exhibit)
+    end
 
-        it 'touches the exhibit to clear any caches' do
-          allow(subject.exhibit).to receive(:touch)
+    it 'applies application metadata' do
+      expect(indexed_document).to include(spotlight_resource_id_ssim: resource.to_global_id.to_s, spotlight_resource_type_ssim: 'spotlight/resources')
+    end
 
-          subject.reindex
+    context 'with some provided metadata' do
+      let(:index_args) { { additional_metadata: { a: 1 } } }
 
-          expect(subject.exhibit).to have_received(:touch)
-        end
+      it 'applies externally provided metadata' do
+        expect(indexed_document).to include a: 1
       end
     end
-  end
 
-  describe '#save_and_index' do
-    before do
-      allow(subject.send(:blacklight_solr)).to receive(:update)
-      allow(subject).to receive(:reindex_later)
-    end
+    it 'touches the exhibit to bust any caches' do
+      allow(exhibit).to receive(:touch)
 
-    it 'saves the object' do
-      expect(subject).to receive(:save).and_return(true)
-      subject.save_and_index
-    end
+      indexed_document
 
-    it 'reindexes after save' do
-      expect(subject).to receive(:save).and_return(true)
-      expect(subject).to receive(:reindex_later)
-      subject.save_and_index
+      expect(exhibit).to have_received(:touch)
     end
 
-    context 'if the save fails' do
-      it 'does not reindex' do
-        expect(subject).to receive(:save).and_return(false)
-        expect(subject).not_to receive(:reindex_later)
-        subject.save_and_index
+    context 'with touch: false' do
+      it 'does not touch the exhibit' do
+        allow(exhibit).to receive(:touch)
+
+        expect(subject.reindex(touch: false) { |*| throw :skip }).to eq 1
+
+        expect(exhibit).not_to have_received(:touch)
       end
     end
   end

data/spec/models/spotlight/resources/iiif_harvester_spec.rb

@@ -3,12 +3,11 @@
 require 'spec_helper'
 
 describe Spotlight::Resources::IiifHarvester do
+  subject(:harvester) { described_class.create(exhibit_id: exhibit.id, url: url) }
+
   let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:harvester) { described_class.create(exhibit_id: exhibit.id, url: url) }
 
   describe 'Validation' do
-    subject { harvester }
-
     context 'when given an invalid URL' do
       before do
         stub_request(:head, 'http://example.com').to_return(status: 200, headers: { 'Content-Type' => 'text/html' })
@@ -38,16 +37,16 @@ describe Spotlight::Resources::IiifHarvester do
     end
   end
 
-  describe '#documents_to_index' do
-    subject { harvester.document_builder }
-
+  describe '#reindex' do
     let(:url) { 'uri://for-top-level-collection' }
 
-    before { stub_default_collection }
+    before do
+      stub_default_collection
+      allow(Spotlight::Engine.config).to receive(:writable_index).and_return(false)
+    end
 
-    it 'returns an Enumerator of all the solr documents' do
-      expect(subject.documents_to_index).to be_a(Enumerator)
-      expect(subject.documents_to_index.count).to eq 8
+    it 'indexes all the solr documents' do
+      expect(subject.reindex).to eq 8
     end
   end
 end

data/spec/models/spotlight/role_spec.rb

@@ -9,7 +9,7 @@ describe Spotlight::Role, type: :model do
 
       it 'does not be valid' do
         expect(subject).not_to be_valid
-        expect(subject.errors.messages).to include(role: ['is not included in the list'], 'user.email': ["can't be blank"])
+        expect(subject.errors.messages.transform_values(&:to_a)).to include(role: ['is not included in the list'], 'user.email': ["can't be blank"])
       end
     end
 

data/spec/models/spotlight/search_spec.rb

@@ -5,7 +5,7 @@ describe Spotlight::Search, type: :model do
 
   let(:exhibit) { FactoryBot.create(:exhibit) }
 
-  let(:query_params) { { 'f' => { 'genre_sim' => ['map'] } } }
+  let(:query_params) { { 'f' => { 'genre_ssim' => ['map'] } } }
 
   let(:blacklight_config) { ::CatalogController.blacklight_config }
   let(:document) do
@@ -17,7 +17,10 @@ describe Spotlight::Search, type: :model do
     let(:query_params) { {} }
 
     it 'has items' do
-      expect(subject.documents.size).to eq 55
+      # Add some fuzziness to this. Running locally it should be 55 but in some
+      # CI environments, spec/features/add_items_spec.rb will end up adding new
+      # records and cannot ensure deletion of them.
+      expect(subject.documents.size).to be_within(1).of(55)
     end
   end
 
@@ -31,6 +34,16 @@ describe Spotlight::Search, type: :model do
     end
   end
 
+  describe '.unpublished' do
+    let!(:search1) { FactoryBot.create(:search, published: true) }
+    let!(:search2) { FactoryBot.create(:search, published: false) }
+    let!(:search3) { FactoryBot.create(:search, published: nil) }
+
+    it 'accounts for nil and false values' do
+      expect(described_class.unpublished.count).to eq 5
+    end
+  end
+
   describe '#slug' do
     let(:search) { FactoryBot.create(:search) }
 
@@ -54,7 +67,7 @@ describe Spotlight::Search, type: :model do
 
   describe '#search_params' do
     it 'maps the search to the appropriate facet values' do
-      expect(subject.search_params.to_hash).to include 'fq' => array_including('{!term f=genre_sim}map')
+      expect(subject.search_params.to_hash).to include 'fq' => array_including('{!term f=genre_ssim}map')
     end
 
     context 'with filter_resources_by_exhibit configured' do
@@ -95,4 +108,18 @@ describe Spotlight::Search, type: :model do
       expect(search_params).to include user_params
     end
   end
+
+  describe '#groups' do
+    let(:search) { FactoryBot.create(:search_with_groups, groups_count: 3) }
+
+    it do
+      expect(search.groups.count).to eq 3
+    end
+
+    it do
+      search.groups.all do |group|
+        expect(group).to be_an Spotlight::Group
+      end
+    end
+  end
 end

data/spec/models/spotlight/solr_document/atomic_updates_spec.rb

@@ -37,6 +37,16 @@ describe Spotlight::SolrDocument::AtomicUpdates, type: :model do
       subject.reindex
     end
 
+    it 'update parameters can be specified to modify commitWithin' do
+      expected = {
+        params: { commitWithin: 5001 },
+        data: [{ id: 'doc_id', a: { set: 1 }, b: { set: 2 }, timestamp: { set: nil } }].to_json,
+        headers: { 'Content-Type' => 'application/json' }
+      }
+      expect(blacklight_solr).to receive(:update).with(expected)
+      subject.reindex(update_params: { commitWithin: 5001 })
+    end
+
     it 'cowardlies refuse to index a document if the only value is an id' do
       allow(subject).to receive_messages(to_solr: { id: 'doc_id' }, timestamp: { set: nil })
       expect(blacklight_solr).not_to receive(:update)

data/spec/models/spotlight/solr_document_sidecar_spec.rb

@@ -20,6 +20,7 @@ describe Spotlight::SolrDocumentSidecar, type: :model do
     context 'with an uploaded item' do
       before do
         subject.data = { 'configured_fields' => { 'some_configured_field' => 'some value' } }
+        subject.resource = Spotlight::Resources::Upload.new
         allow(Spotlight::Resources::Upload).to receive(:fields).with(exhibit).and_return([uploaded_field_config])
       end
 

data/spec/presenters/spotlight/iiif_manifest_presenter_spec.rb

@@ -16,7 +16,7 @@ describe Spotlight::IiifManifestPresenter do
   end
 
   describe 'public methods' do
-    let(:helpers) { double(show_presenter: presenter) }
+    let(:helpers) { double(document_presenter: presenter) }
     let(:presenter) { instance_double(Blacklight::ShowPresenter, heading: title_field_value) }
 
     let(:iiif_url) { 'https://iiif.test/images/1-1' }

data/spec/services/spotlight/bulk_updates_csv_template_service_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spotlight::BulkUpdatesCsvTemplateService do
+  subject(:service) { described_class.new(exhibit: exhibit) }
+
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+  let!(:tag1) { FactoryBot.create(:tagging, tagger: exhibit, taggable: exhibit) }
+  let!(:tag2) { FactoryBot.create(:tagging, tagger: exhibit, taggable: exhibit) }
+
+  describe '#template' do
+    let(:view_context) { double('ViewContext', document_presenter: double('DocumentPresenter', heading: 'Document Title')) }
+
+    it 'has a row for every document (+ the header)' do
+      template = CSV.parse(service.template(view_context: view_context).to_a.join)
+      expect(template).to have_at_least(56).items
+      expect(template[0].join(',')).to match(/Item ID,Item Title,Visibility,Tag: tagging\d,Tag: tagging\d/)
+    end
+
+    it 'only has requested columns' do
+      template = CSV.parse(service.template(view_context: view_context, tags: false).to_a.join)
+      expect(template[0].join(',')).to eq 'Item ID,Item Title,Visibility'
+    end
+  end
+end

data/spec/services/spotlight/etl/context_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::Context do
+  subject(:context) { described_class.new(resource, **context_args) }
+
+  let(:resource) { instance_double(Spotlight::Resource, id: 123, document_model: SolrDocument) }
+  let(:context_args) { {} }
+
+  describe '#resource' do
+    it 'extracts the Spotlight::Resource from the argument list' do
+      expect(context.resource).to eq resource
+    end
+  end
+
+  describe '#unique_key' do
+    let(:data) { { id: '123' } }
+
+    it 'tries to get a usable unique key for a transformed document' do
+      expect(context.unique_key(data)).to eq '123'
+    end
+  end
+
+  describe '#on_error' do
+    context 'with a class-level handler' do
+      let(:handler) { instance_double(Proc, call: nil) }
+
+      it 'calls the class-level handler' do
+        allow(described_class).to receive(:error_reporter).and_return(handler)
+
+        subject.on_error(nil, nil, {})
+
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'with an instance-level handler' do
+      let(:context_args) { { on_error: handler } }
+      let(:handler) { instance_double(Proc, call: nil) }
+
+      it 'calls the instance-level handler' do
+        subject.on_error(nil, nil, {})
+
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'with :log' do
+      it 'logs an error' do
+        allow(Rails.logger).to receive(:error)
+
+        subject.on_error(nil, nil, {})
+
+        expect(Rails.logger).to have_received(:error).with(/Pipeline error/)
+      end
+    end
+
+    context 'with :exception' do
+      let(:context_args) { { on_error: :exception } }
+      let(:e) { StandardError.new('asdf') }
+
+      it 'raises an exception' do
+        expect { subject.on_error(nil, e, {}) }.to raise_exception(e)
+      end
+    end
+  end
+end