blacklight-spotlight 3.0.0.alpha.9 → 3.0.0.rc4

data/spec/models/spotlight/featured_image_spec.rb

@@ -3,6 +3,22 @@
 describe Spotlight::FeaturedImage do
   subject(:featured_image) { described_class.new }
 
+  let(:temp_image) { FactoryBot.create(:temporary_image) }
+
+  context 'with an uploaded image' do
+    it 'copies the temporary uploaded image to this model' do
+      featured_image.source = 'remote'
+      featured_image.upload_id = temp_image.id
+
+      featured_image.save
+
+      expect(featured_image.image.filename).to eq temp_image.image.filename
+      expect(featured_image.image.read).to eq temp_image.image.read
+
+      expect { temp_image.reload }.to raise_exception ActiveRecord::RecordNotFound
+    end
+  end
+
   describe '#iiif_url' do
     let(:iiif_tilesource) { 'http://example.com/iiif/abc123/info.json' }
     let(:iiif_region) { '0,0,400,300' }
@@ -17,6 +33,17 @@ describe Spotlight::FeaturedImage do
         expect(subject.iiif_url).to match(%r{^http://example.com/iiif/abc123/})
         expect(subject.iiif_url).not_to include('info.json')
       end
+
+      context 'with an uploaded image' do
+        before do
+          featured_image.image = temp_image.image
+          featured_image.save!
+        end
+
+        it 'points at the RIIIF endpoint' do
+          expect(subject.iiif_url).to match(%r{^/images/\d+/})
+        end
+      end
     end
 
     describe 'region' do

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/main_navigation_spec.rb

@@ -7,7 +7,7 @@ describe Spotlight::MainNavigation, type: :model do
 
   it 'has a default_label' do
     subject.nav_type = :curated_features
-    expect(subject.default_label).to eq 'Curated Features'
+    expect(subject.default_label).to eq 'Curated features'
   end
 
   it 'returns the use the default label in the absence of a label' do

data/spec/models/spotlight/page_spec.rb

@@ -119,7 +119,7 @@ describe Spotlight::Page, type: :model do
   end
 
   describe '#slug' do
-    let(:page) { FactoryBot.create(:feature_page) }
+    let(:page) { FactoryBot.create(:about_page) }
 
     it 'gets a default slug' do
       expect(page.slug).not_to be_blank
@@ -130,6 +130,11 @@ describe Spotlight::Page, type: :model do
       expect(page.slug).to eq 'abc'
     end
 
+    it 'blacklists contacts' do
+      page.update(title: 'contacts')
+      expect(page.slug).not_to eq 'contacts'
+    end
+
     context 'with a custom slug' do
       let(:page) { FactoryBot.create(:feature_page, slug: 'xyz') }
 

data/spec/models/spotlight/reindex_progress_spec.rb

@@ -1,122 +1,124 @@
 # frozen_string_literal: true
 
 describe Spotlight::ReindexProgress, type: :model do
-  let(:reindexing_log_entry) do
-    FactoryBot.create(:failed_reindexing_log_entry, items_reindexed_estimate: 12)
+  subject(:progress) { described_class.new(exhibit) }
+
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+  let!(:job_tracker) do
+    FactoryBot.create(
+      :job_tracker,
+      resource: exhibit,
+      on: exhibit,
+      job_class: 'Spotlight::ReindexExhibitJob',
+      updated_at: Time.zone.now,
+      **job_tracker_args
+    )
   end
+  let(:job_tracker_args) { {} }
 
-  let(:subject) { described_class.new(reindexing_log_entry) }
+  context 'with a completed job' do
+    let(:job_tracker_args) { { status: 'completed', data: { progress: 50, total: 50 } } }
 
-  describe '#started_at' do
-    it 'returns start_time for current_log_entry' do
-      expect(subject.started_at).to eq reindexing_log_entry.start_time
+    it 'reports on reindexing progress' do
+      expect(progress.as_json).to include(
+        completed: 50,
+        total: 50,
+        finished: true,
+        errored: false,
+        recently_in_progress: true
+      )
     end
   end
 
-  describe '#updated_at' do
-    it 'returns the time of last update for current_log_entry' do
-      expect(subject.updated_at).to eq reindexing_log_entry.updated_at
-    end
-  end
+  context 'with a failed job' do
+    let(:job_tracker_args) { { status: 'failed', data: { progress: 32, total: 50 } } }
 
-  describe '#finished?' do
-    it 'returns true if current_log_entry is succeeded or failed' do
-      expect(subject.finished?).to be true
+    it 'reports on reindexing progress' do
+      expect(progress.as_json).to include(
+        completed: 32,
+        total: 50,
+        finished: true,
+        errored: true
+      )
     end
   end
 
-  describe '#finished_at' do
-    it 'returns end_time for current_log_entry' do
-      expect(subject.finished_at).to eq(reindexing_log_entry.end_time)
+  context 'with an in-progress job' do
+    before do
+      FactoryBot.create(:job_tracker, on: job_tracker, resource: exhibit, data: { progress: 32, total: 32 }, status: 'completed')
+      FactoryBot.create(:job_tracker, on: job_tracker, resource: exhibit, data: { progress: 16, total: 50 }, status: 'in_progress')
     end
-  end
 
-  describe '#total' do
-    it 'returns items_reindexed_estimate for current_log_entry' do
-      expect(subject.total).to be 12
-    end
-  end
+    let(:job_tracker_args) { { status: 'in_progress' } }
 
-  describe '#completed' do
-    it 'returns items_reindexed_count for current_log_entry' do
-      expect(subject.completed).to be 10
+    it 'harvests total and completed data from the child jobs' do
+      expect(progress.as_json).to include(
+        completed: 48,
+        total: 82
+      )
     end
-  end
 
-  describe '#errored?' do
-    it 'returns true for log entries marked as failed' do
-      expect(subject).to be_errored
-    end
-  end
+    it 'is not completed until all the child jobs are finished' do
+      job_tracker.update(status: 'failed')
 
-  describe '#as_json' do
-    it 'returns a hash with values for current_log_entry via the various helper methods' do
-      expect(subject.as_json).to eq(
-        recently_in_progress: subject.recently_in_progress?,
-        started_at: I18n.l(reindexing_log_entry.start_time, format: :long),
-        finished_at: I18n.l(reindexing_log_entry.end_time, format: :long),
-        updated_at: I18n.l(reindexing_log_entry.updated_at, format: :long),
-        total: subject.total,
-        completed: subject.completed,
-        errored: subject.errored?,
-        finished: subject.finished?
+      expect(progress.as_json).to include(
+        finished: false,
+        errored: true
       )
     end
   end
 
-  describe '#recently_in_progress?' do
-    context 'there is no end_time for current_log_entry' do
-      let(:reindexing_log_entry) { FactoryBot.create(:in_progress_reindexing_log_entry) }
-
-      it 'returns true' do
-        expect(subject).to be_recently_in_progress
-      end
+  context 'with no job' do
+    before do
+      job_tracker.delete
     end
 
-    context 'current_log_entry has an end_time less than Spotlight::Engine.config.reindex_progress_window.minutes.ago' do
-      let(:reindexing_log_entry) { FactoryBot.create(:recent_reindexing_log_entry, end_time: Time.zone.now) }
-
-      it 'returns true' do
-        expect(subject).to be_recently_in_progress
-      end
+    it 'reports on reindexing progress' do
+      expect(progress.as_json).to include(
+        completed: 0,
+        total: 0,
+        finished: false,
+        errored: false,
+        recently_in_progress: false
+      )
     end
+  end
 
-    context 'current_log_entry is unstarted ' do
-      let(:reindexing_log_entry) { FactoryBot.create(:unstarted_reindexing_log_entry) }
+  context 'with multiple job trackers' do
+    let(:job_tracker_args) { { status: 'in_progress' } }
+
+    before do
+      FactoryBot.create(
+        :job_tracker,
+        resource: exhibit,
+        on: exhibit,
+        job_class: 'Spotlight::ReindexExhibitJob',
+        updated_at: Time.zone.now,
+        status: 'completed'
+      )
+    end
 
-      it 'returns false' do
-        expect(subject).not_to be_recently_in_progress
-      end
+    it 'uses the currently in-progress tracker' do
+      expect(progress.as_json).to include(finished: false)
     end
   end
 
-  context 'current_log_entry is blan' do
-    let(:reindexing_log_entry) { Spotlight::ReindexingLogEntry.new }
-
-    # rubocop:disable RSpec/MultipleExpectations
-    it 'methods return gracefully' do
-      expect(subject.recently_in_progress?).to be false
-      expect(subject.started_at).to be nil
-      expect(subject.updated_at).to be nil
-      expect(subject.finished?).to be false
-      expect(subject.finished_at).to be nil
-      expect(subject.total).to be nil
-      expect(subject.completed).to be nil
-      expect(subject.errored?).to be false
-      expect(subject.send(:localized_start_time)).to be nil
-      expect(subject.send(:localized_finish_time)).to be nil
-      expect(subject.send(:localized_updated_time)).to be nil
-      expect(subject.as_json).to eq(
-        recently_in_progress: false,
-        started_at: nil,
-        finished_at: nil,
-        updated_at: nil,
-        total: nil,
-        completed: nil,
-        errored: false,
-        finished: false
+  context 'with multiple in-progress trackers' do
+    let(:job_tracker_args) { { status: 'in_progress' } }
+
+    before do
+      FactoryBot.create(
+        :job_tracker,
+        resource: exhibit,
+        on: exhibit,
+        job_class: 'Spotlight::ReindexExhibitJob',
+        updated_at: Time.zone.now - 5.years,
+        status: 'in_progress'
       )
     end
-    # rubocop:enable RSpec/MultipleExpectations
+
+    it 'uses the most recently updated tracker' do
+      expect(Time.zone.parse(progress.as_json[:updated_at]).year).to eq job_tracker.updated_at.year
+    end
   end
 end

data/spec/models/spotlight/resource_spec.rb

@@ -1,126 +1,105 @@
 # 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
+  describe '#save_and_index' do
+    before do
+      allow(subject).to receive(:save)
+      allow(subject).to receive(:reindex_later)
+    end
 
-      let(:solr_response) { { id: 123 } }
+    it 'saves the object' do
+      expect(subject).to receive(:save).and_return(true)
+      subject.save_and_index
+    end
 
-      before do
-        SolrDocument.new(id: 123).sidecars.create!(exhibit: exhibit, data: { document_data: true })
-        allow(subject).to receive_messages(to_global_id: '')
+    it 'reindexes after save' do
+      expect(subject).to receive(:save).and_return(true)
+      expect(subject).to receive(:reindex_later)
+      subject.save_and_index
+    end
 
-        allow(subject.document_builder).to receive(:to_solr).and_return(solr_response)
+    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
 
-      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)
-
-          expect(data.length).to eq 1
-          doc = data.first
-
-          break if doc.first == :commit
-
-          expect(doc).to include document_data: true
-        end
-
-        subject.reindex
-      end
+  describe '#reindex' do
+    before do
+      # sneak some data into the pipeline
+      subject.indexing_pipeline.transforms = [->(*) { { id: '123' } }] + subject.indexing_pipeline.transforms
+    end
 
-      context 'when a document does not have an identifier' do
-        let(:solr_response) { { other_field: 'Content' } }
+    let(:indexed_document) do
+      result = nil
 
-        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)
+      subject.reindex(**index_args) do |data, *|
+        result = data
 
-          subject.reindex
-        end
+        # skip actually indexing the document into the solr index
+        throw :skip
       end
 
-      context 'reindexing_log_entry is provided' do
-        before do
-          allow(subject.send(:blacklight_solr)).to receive(:update)
-        end
-
-        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
-      end
+      result
+    end
 
-      context 'when the index is not writable' do
-        before do
-          allow(Spotlight::Engine.config).to receive_messages(writable_index: false)
-        end
+    let(:index_args) { {} }
 
-        it "doesn't write" do
-          expect(subject.send(:blacklight_solr)).not_to receive(:update)
-          subject.reindex
-        end
-      end
+    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