blacklight-spotlight 3.0.0.rc3 → 3.0.1

data/spec/models/spotlight/ability_spec.rb

@@ -80,6 +80,7 @@ describe Spotlight::Ability, type: :model do
     it { is_expected.to be_able_to(:destroy, translation) }
 
     it { is_expected.to be_able_to(:tag, exhibit) }
+    it { is_expected.to be_able_to(:bulk_update, exhibit) }
 
     it { is_expected.to be_able_to(:edit, contact) }
     it { is_expected.to be_able_to(:new, contact) }
@@ -88,4 +89,30 @@ describe Spotlight::Ability, type: :model do
     it { is_expected.not_to be_able_to(:manage, language) }
     it { is_expected.to be_able_to(:read, language) }
   end
+
+  context 'with an unpublished exhibit' do
+    before do
+      exhibit.update(published: false)
+    end
+
+    context 'with a user with a viewer role' do
+      let(:user) { FactoryBot.create(:user, :with_exhibit_role, role: 'viewer', exhibit: exhibit) }
+
+      it { is_expected.not_to be_able_to(:create, exhibit) }
+      it { is_expected.to be_able_to(:read, exhibit) }
+      it { is_expected.to be_able_to(:read, page) }
+      it { is_expected.not_to be_able_to(:create, Spotlight::Page.new(exhibit: exhibit)) }
+      it { is_expected.to be_able_to(:read, search) }
+      it { is_expected.to be_able_to(:read, public_language) }
+      it { is_expected.not_to be_able_to(:read, language) }
+      it { is_expected.not_to be_able_to(:read, unpublished_search) }
+      it { is_expected.not_to be_able_to(:tag, exhibit) }
+    end
+
+    context 'with an anonymous user' do
+      let(:user) { FactoryBot.create(:exhibit_visitor) }
+
+      it { is_expected.not_to be_able_to(:read, exhibit) }
+    end
+  end
 end

data/spec/models/spotlight/background_job_progress_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+describe Spotlight::BackgroundJobProgress, type: :model do
+  subject(:progress) { described_class.new(exhibit, job_class: Spotlight::ReindexExhibitJob) }
+
+  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) { {} }
+
+  context 'with a completed job' do
+    let(:job_tracker_args) { { status: 'completed', data: { progress: 50, total: 50 } } }
+
+    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
+
+  context 'with a failed job' do
+    let(:job_tracker_args) { { status: 'failed', data: { progress: 32, total: 50 } } }
+
+    it 'reports on reindexing progress' do
+      expect(progress.as_json).to include(
+        completed: 32,
+        total: 50,
+        finished: true,
+        errored: true
+      )
+    end
+  end
+
+  context 'with an in-progress job' do
+    let(:job_tracker_args) { { status: 'in_progress', data: { progress: 32, total: 50 } } }
+
+    it 'reports on reindexing progress' do
+      expect(progress.as_json).to include(
+        completed: 32,
+        total: 50,
+        finished: false,
+        errored: false
+      )
+    end
+  end
+
+  context 'with an in-progress job with subtasks' 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
+
+    let(:job_tracker_args) { { status: 'in_progress' } }
+
+    it 'harvests total and completed data from the child jobs' do
+      expect(progress.as_json).to include(
+        completed: 48,
+        total: 82
+      )
+    end
+
+    it 'is not completed until all the child jobs are finished' do
+      job_tracker.update(status: 'failed')
+
+      expect(progress.as_json).to include(
+        finished: false,
+        errored: true
+      )
+    end
+  end
+
+  context 'with no job' do
+    before do
+      job_tracker.delete
+    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 '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 'uses the currently in-progress tracker' do
+      expect(progress.as_json).to include(finished: false)
+    end
+  end
+
+  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
+
+    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/blacklight_configuration_spec.rb

@@ -314,7 +314,7 @@ describe Spotlight::BlacklightConfiguration, type: :model do
     context 'title only configuration' do
       before do
         blacklight_config.configure do |config|
-          config.view.gallery.title_only_by_default = true
+          config.view.gallery(title_only_by_default: true)
           config.add_index_field 'a'
         end
       end
@@ -449,11 +449,16 @@ describe Spotlight::BlacklightConfiguration, type: :model do
 
       expect(subject.blacklight_config.per_page).to eq [10, 50]
     end
+  end
 
-    it 'prepends the default per page' do
-      blacklight_config.per_page = [1, 10, 50, 100]
+  describe '#default_per_page' do
+    it 'is the first per page option by default' do
+      expect(subject.blacklight_config.default_per_page).to eq 10
+    end
+
+    it "is set from the model's default_per_page" do
       subject.default_per_page = 50
-      expect(subject.blacklight_config.per_page.first).to eq 50
+      expect(subject.blacklight_config.default_per_page).to eq 50
     end
   end
 
@@ -473,20 +478,20 @@ describe Spotlight::BlacklightConfiguration, type: :model do
     # rubocop:disable RSpec/PredicateMatcher
     it 'filters the upstream blacklight config' do
       subject.document_index_view_types = %w[list gallery unknown]
-      blacklight_config.view.list
-      blacklight_config.view.gallery
-      blacklight_config.view.something
+      blacklight_config.view.list!
+      blacklight_config.view.gallery!
+      blacklight_config.view.something!
 
       expect(subject.blacklight_config.view.keys).to include :list, :gallery, :something
-      expect(subject.blacklight_config.view.all? { |k, v| v.key == k && v.if == :enabled_in_spotlight_view_type_configuration? }).to be_truthy
+      expect(subject.blacklight_config.view.select { |k, v| v.key == k && v.if == :enabled_in_spotlight_view_type_configuration? }.any?).to be_truthy
     end
     # rubocop:enable RSpec/PredicateMatcher
 
     it 'passes through the blacklight configuration when not set' do
-      blacklight_config.view.list
-      blacklight_config.view.gallery
-      blacklight_config.view.something
-      expect(subject.blacklight_config.view.keys).to include(*blacklight_config.view.keys)
+      blacklight_config.view.list!
+      blacklight_config.view.gallery!
+      blacklight_config.view.something!
+      expect(subject.blacklight_config.view.keys.map(&:to_s)).to include(*blacklight_config.view.keys.map(&:to_s))
     end
   end
 
@@ -622,9 +627,9 @@ describe Spotlight::BlacklightConfiguration, type: :model do
 
   describe '#document_index_view_types_selected_hash' do
     before do
-      subject.default_blacklight_config.view.list
-      subject.default_blacklight_config.view.gallery
-      subject.default_blacklight_config.view.map
+      subject.default_blacklight_config.view.list!
+      subject.default_blacklight_config.view.gallery!
+      subject.default_blacklight_config.view.whatever!
       subject.default_blacklight_config.view.rss.if = false
       subject.document_index_view_types = %w[list gallery rss]
     end
@@ -633,8 +638,8 @@ describe Spotlight::BlacklightConfiguration, type: :model do
       expect(subject.document_index_view_types_selected_hash.to_h).to include list: true, gallery: true
     end
 
-    it 'disabled view types are not included' do
-      expect(subject.document_index_view_types_selected_hash.to_h).not_to include :map
+    it 'disabled view types use the value false' do
+      expect(subject.document_index_view_types_selected_hash.to_h).to include whatever: false
     end
 
     it 'excludes view types disabled by configuration (not by curator settings)' do

data/spec/models/spotlight/browse_category_search_builder_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+describe Spotlight::BrowseCategorySearchBuilder do
+  class BrowseCategoryMockSearchBuilder < Blacklight::SearchBuilder
+    include Blacklight::Solr::SearchBuilderBehavior
+    include Spotlight::BrowseCategorySearchBuilder
+  end
+
+  subject { BrowseCategoryMockSearchBuilder.new(scope).with(blacklight_params) }
+
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+  let(:scope) { double(blacklight_config: exhibit.blacklight_config, current_exhibit: exhibit) }
+  let(:solr_request) { Blacklight::Solr::Request.new }
+  let(:blacklight_params) { { browse_category_id: search.id } }
+  let(:search) { FactoryBot.create(:search, exhibit: exhibit, query_params: { sort: 'type', f: { genre_ssim: ['term'] }, q: 'search query' }) }
+
+  describe '#restrict_to_browse_category' do
+    it 'adds the search query parameters from the browse category' do
+      params = subject.to_hash.with_indifferent_access
+
+      expect(params).to include(
+        q: 'search query',
+        fq: ['{!term f=genre_ssim}term'],
+        sort: 'sort_type_ssi asc'
+      )
+    end
+
+    context 'with a user-provided query' do
+      let(:blacklight_params) { { browse_category_id: search.id, q: 'cats' } }
+
+      it 'uses the user-provided query to further restrict the search' do
+        params = subject.to_hash.with_indifferent_access
+        expect(params).not_to include(:q)
+        expect(params).to include(
+          json: {
+            query: {
+              bool: {
+                must: [
+                  { edismax: { query: 'cats' } },
+                  { edismax: { query: 'search query' } }
+                ]
+              }
+            }
+          }
+        )
+      end
+    end
+  end
+end

data/spec/models/spotlight/exhibit_spec.rb

@@ -253,48 +253,9 @@ describe Spotlight::Exhibit, type: :model do
   describe '#reindex_later' do
     subject { FactoryBot.create(:exhibit) }
 
-    let(:log_entry) { Spotlight::ReindexingLogEntry.new(exhibit: subject, user: user, items_reindexed_count: 0) }
-
-    context 'user is omitted' do
-      let(:user) { nil }
-
-      it 'queues a reindex job for the exhibit, with nil user for the log entry' do
-        expect(subject).to receive(:new_reindexing_log_entry).with(nil).and_return(log_entry)
-        expect(Spotlight::ReindexJob).to receive(:perform_later).with(subject, log_entry)
-        subject.reindex_later
-        expect(log_entry.user).to be nil
-      end
-    end
-
-    context 'non-nil user is provided' do
-      let(:user) { FactoryBot.build(:user) }
-
-      it 'queues a reindex job for the exhibit, with actual user for the log entry' do
-        expect(subject).to receive(:new_reindexing_log_entry).with(user).and_return(log_entry)
-        expect(Spotlight::ReindexJob).to receive(:perform_later).with(subject, log_entry)
-        subject.reindex_later user
-        expect(log_entry.user).to eq user
-      end
-    end
-  end
-
-  describe '#new_reindexing_log_entry' do
-    let(:user) { FactoryBot.build(:user) }
-
-    it 'returns a properly configured Spotlight::ReindexingLogEntry instance' do
-      reindexing_log_entry = subject.send(:new_reindexing_log_entry, user)
-      expect(reindexing_log_entry.exhibit).to eq subject
-      expect(reindexing_log_entry.user).to eq user
-      expect(reindexing_log_entry.items_reindexed_count).to eq 0
-      expect(reindexing_log_entry.unstarted?).to be true
-    end
-
-    it 'does not require user the user parameter' do
-      reindexing_log_entry = subject.send(:new_reindexing_log_entry)
-      expect(reindexing_log_entry.exhibit).to eq subject
-      expect(reindexing_log_entry.user).to be nil
-      expect(reindexing_log_entry.items_reindexed_count).to eq 0
-      expect(reindexing_log_entry.unstarted?).to be true
+    it 'queues a reindex job for the exhibit' do
+      expect(Spotlight::ReindexExhibitJob).to receive(:perform_later).with(subject, user: nil)
+      subject.reindex_later
     end
   end
 
@@ -366,24 +327,9 @@ describe Spotlight::Exhibit, type: :model do
   end
 
   describe '#reindex_progress' do
-    let!(:reindexing_log_entries) do
-      [
-        FactoryBot.create(:unstarted_reindexing_log_entry, exhibit: exhibit),
-        FactoryBot.create(:reindexing_log_entry, exhibit: exhibit),
-        in_progress_entry,
-        FactoryBot.create(:failed_reindexing_log_entry, exhibit: exhibit),
-        FactoryBot.create(:unstarted_reindexing_log_entry, exhibit: exhibit)
-      ]
-    end
-
-    let(:in_progress_entry) do
-      FactoryBot.create(:in_progress_reindexing_log_entry, exhibit: exhibit)
-    end
-
     it 'returns the latest log entry that is not unstarted' do
       reindex_progress = subject.reindex_progress
-      expect(reindex_progress).to be_a Spotlight::ReindexProgress
-      expect(reindex_progress.current_log_entry).to eq in_progress_entry
+      expect(reindex_progress).to be_a Spotlight::BackgroundJobProgress
     end
   end
 

data/spec/models/spotlight/featured_image_spec.rb

@@ -5,6 +5,18 @@ describe Spotlight::FeaturedImage do
 
   let(:temp_image) { FactoryBot.create(:temporary_image) }
 
+  describe '#bust_containing_resource_caches' do
+    let!(:feature_page) { FactoryBot.create(:feature_page, thumbnail: temp_image) }
+    let!(:feature_page2) { FactoryBot.create(:feature_page, thumbnail: temp_image) }
+
+    it 'changes the updated_at for all resources that might be using this image' do
+      temp_image.save
+
+      expect(feature_page.updated_at).to be < feature_page.reload.updated_at
+      expect(feature_page2.updated_at).to be < feature_page2.reload.updated_at
+    end
+  end
+
   context 'with an uploaded image' do
     it 'copies the temporary uploaded image to this model' do
       featured_image.source = 'remote'
@@ -41,7 +53,7 @@ describe Spotlight::FeaturedImage do
         end
 
         it 'points at the RIIIF endpoint' do
-          expect(subject.iiif_url).to match(%r{^/images/\d+/})
+          expect(subject.iiif_url).to match(%r{^/images/\d+-.+/})
         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