blacklight-spotlight 3.0.0.alpha.10 → 3.0.0.rc5

data/spec/jobs/spotlight/process_bulk_updates_csv_job_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+def tag_names(exhibit, id)
+  exhibit.blacklight_config.repository.find(id).documents.first.sidecar(exhibit).taggings.includes(:tag).map { |tagging| tagging&.tag&.name }
+end
+
+describe Spotlight::ProcessBulkUpdatesCsvJob do
+  subject { described_class.new(exhibit, bulk_update) }
+
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+
+  describe 'visibility' do
+    let(:bulk_update) { FactoryBot.create(:bulk_update, exhibit: exhibit) }
+
+    it 'is updated' do
+      allow(SolrDocument.index.connection).to receive(:update).and_call_original
+      expect(exhibit.blacklight_config.repository.find('dq287tq6352').documents.first).not_to be_private(exhibit)
+
+      subject.perform_now
+
+      expect(exhibit.blacklight_config.repository.find('dq287tq6352').documents.first).to be_private(exhibit)
+      expect(SolrDocument.index.connection).to have_received(:update)
+    end
+
+    context 'with a row that does not change visibility' do
+      before do
+        sidecar = exhibit.solr_document_sidecars.find_or_create_by(document_type: 'SolrDocument', document_id: 'dq287tq6352')
+        sidecar.private!
+      end
+
+      it 'does not update solr' do
+        allow(SolrDocument.index.connection).to receive(:update)
+
+        subject.perform_now
+
+        expect(SolrDocument.index.connection).not_to have_received(:update)
+      end
+    end
+  end
+
+  describe 'tags' do
+    let(:bulk_update) { FactoryBot.create(:tagged_bulk_update, exhibit: exhibit) }
+
+    before do
+      document = exhibit.blacklight_config.repository.find('cz507zk0531').documents.first
+      exhibit.tag(document.sidecar(exhibit), with: 'CSV Tag1', on: :tags)
+    end
+
+    it 'are added/removed' do
+      allow(SolrDocument.index.connection).to receive(:update).and_call_original
+      expect(tag_names(exhibit, 'bm387cy2596')).to be_empty
+      expect(tag_names(exhibit, 'cz507zk0531')).to eq(['CSV Tag1'])
+      expect(tag_names(exhibit, 'dq287tq6352')).to be_empty
+      subject.perform_now
+      expect(tag_names(exhibit, 'bm387cy2596')).to eq(['CSV Tag1', 'CSV Tag2'])
+      expect(tag_names(exhibit, 'cz507zk0531')).to eq(['CSV Tag2'])
+      expect(tag_names(exhibit, 'dq287tq6352')).to eq(['CSV Tag1', 'CSV Tag2'])
+
+      # 3 updates plus the final commit
+      expect(SolrDocument.index.connection).to have_received(:update).exactly(4).times
+    end
+
+    context 'with a row that does not change visibility' do
+      before do
+        # set up the documents to match what's the in the spreadsheet already
+        subject.perform_now
+      end
+
+      it 'does not update solr' do
+        allow(SolrDocument.index.connection).to receive(:update)
+
+        subject.perform_now
+
+        expect(SolrDocument.index.connection).not_to have_received(:update)
+      end
+    end
+  end
+end

data/spec/jobs/spotlight/reindex_exhibit_job_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+describe Spotlight::ReindexExhibitJob do
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+
+  before do
+    FactoryBot.create_list(:resource, 10, exhibit: exhibit)
+    allow(Spotlight::ReindexJob).to receive(:perform_now)
+    allow(Spotlight::ReindexJob).to receive(:perform_later)
+  end
+
+  context 'with a single batch' do
+    it 'runs the index job inline' do
+      described_class.perform_now(exhibit, batch_count: 1)
+
+      expect(Spotlight::ReindexJob).to have_received(:perform_now).once.with(exhibit, anything)
+    end
+  end
+
+  context 'with a fixed batch count' do
+    it 'enqueues that number of batches' do
+      described_class.perform_now(exhibit, batch_count: 2)
+
+      expect(Spotlight::ReindexJob).to have_received(:perform_later).twice.with(exhibit, hash_including(:start, :finish))
+    end
+  end
+
+  context 'with a dynamically generated batch count' do
+    it 'enqueues the right number of batches' do
+      described_class.perform_now(exhibit, batch_count: nil, batch_size: 2)
+
+      expect(Spotlight::ReindexJob).to have_received(:perform_later).exactly(5).times.with(exhibit, hash_including(:start, :finish))
+    end
+  end
+
+  context 'with a dynamically generated batch size' do
+    it 'figues out that number of batches' do
+      described_class.perform_now(exhibit, batch_count: nil, batch_size: nil)
+
+      expect(Spotlight::ReindexJob).to have_received(:perform_later).exactly(3).times.with(exhibit, hash_including(:start, :finish))
+    end
+  end
+end

data/spec/jobs/spotlight/reindex_job_spec.rb

@@ -4,67 +4,13 @@ describe Spotlight::ReindexJob do
   include ActiveJob::TestHelper
 
   let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:resource) { FactoryBot.create(:resource) }
+  let(:resource) { FactoryBot.create(:resource, exhibit: exhibit) }
   let(:user) { FactoryBot.create(:user) }
-  let(:log_entry) { Spotlight::ReindexingLogEntry.create(exhibit: exhibit, user: user) }
 
   before do
-    ActiveJob::Base.queue_adapter = :test
     allow_any_instance_of(Spotlight::Resource).to receive(:reindex)
   end
 
-  context 'with an exhibit' do
-    subject { described_class.new(exhibit) }
-
-    before do
-      exhibit.resources << resource
-      exhibit.save
-    end
-
-    it 'attempts to reindex every resource in the exhibit' do
-      # ActiveJob will reload the collection, so we go through a little trouble:
-      expect_any_instance_of(Spotlight::Resource).to receive(:reindex) do |thingy|
-        expect(exhibit.resources).to include thingy
-      end
-
-      subject.perform_now
-    end
-
-    context 'with a log_entry' do
-      subject { described_class.new(exhibit, log_entry) }
-
-      it 'marks the log entry as started' do
-        expect(log_entry).to receive(:in_progress!)
-        subject.perform_now
-      end
-
-      it 'marks the log entry as successful if there is no error' do
-        expect(log_entry).to receive(:succeeded!)
-        subject.perform_now
-      end
-
-      it 'marks the log entry as failed if there is an error' do
-        unexpected_error = StandardError.new
-        # it'd be more realistic to raise on resource#reindex, but that's already stubbed above, so this'll have to do
-        expect(subject).to receive(:perform).with(exhibit, log_entry).and_raise unexpected_error
-        expect(log_entry).to receive(:failed!)
-        expect { subject.perform_now }.to raise_error unexpected_error
-      end
-
-      it 'updates the items_reindexed_estimate field on the log entry' do
-        expect(log_entry).to receive(:update).with(items_reindexed_estimate: 1)
-        subject.perform_now
-      end
-
-      it 'passes log_entry to the resource.reindex call' do
-        # ActiveJob will reload the collection, so we go through a little trouble:
-        expect_any_instance_of(Spotlight::Resource).to receive(:reindex).with(log_entry).exactly(:once)
-        # expect(resource).to receive(:reindex).with(log_entry)
-        subject.perform_now
-      end
-    end
-  end
-
   context 'with a resource' do
     subject { described_class.new(resource) }
 
@@ -72,34 +18,62 @@ describe Spotlight::ReindexJob do
       expect(resource).to receive(:reindex)
       subject.perform_now
     end
+
+    it 'adds some job tracking events' do
+      expect { subject.perform_now }.to change(Spotlight::Event, :count).by(1)
+    end
   end
 
   describe 'validity' do
-    subject { described_class.new(resource, nil, 'xyz') }
+    subject { described_class.new(resource, 'validity_token' => 'xyz') }
 
     let(:mock_checker) { instance_double(Spotlight::ValidityChecker) }
 
     before do
       allow(described_class).to receive(:validity_checker).and_return(mock_checker)
-      allow(mock_checker).to receive(:mint).with(resource).and_return('xyz')
+      allow(mock_checker).to receive(:mint).with(anything).and_return('xyz')
     end
 
     it 'mints a new validity token' do
-      expect { described_class.perform_later(resource) }.to have_enqueued_job(described_class).with(resource, nil, 'xyz')
+      expect { described_class.perform_later(resource) }.to have_enqueued_job(described_class).with(resource, 'validity_token' => 'xyz')
     end
 
     it 'does nothing if the token is no longer valid' do
-      allow(mock_checker).to receive(:check).with(resource, 'xyz').and_return(false)
+      allow(mock_checker).to receive(:check).with(subject, validity_token: 'xyz').and_return(false)
       expect(resource).not_to receive(:reindex)
 
       subject.perform_now
     end
 
     it 'indexes the resource if the token is valid' do
-      allow(mock_checker).to receive(:check).with(resource, 'xyz').and_return(true)
+      allow(mock_checker).to receive(:check).with(subject, validity_token: 'xyz').and_return(true)
       expect(resource).to receive(:reindex)
 
       subject.perform_now
     end
   end
+
+  context 'with start and finish' do
+    it 'indexes the resources within that page' do
+      count = 0
+      allow_any_instance_of(Spotlight::Resource).to receive(:reindex) do
+        count += 1
+      end
+
+      described_class.perform_now(exhibit, start: 0, finish: resource.id)
+
+      expect(count).to eq 1
+    end
+
+    it 'does not index resources off that page' do
+      count = 0
+      allow_any_instance_of(Spotlight::Resource).to receive(:reindex) do
+        count += 1
+      end
+
+      described_class.perform_now(exhibit, start: resource.id + 1, finish: resource.id + 500)
+
+      expect(count).to eq 0
+    end
+  end
 end

data/spec/jobs/spotlight/remove_tags_job_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+describe Spotlight::RemoveTagsJob do
+  subject { described_class.new(solr_params: solr_params, exhibit: exhibit, tags: tags) }
+
+  let(:solr_params) { { q: 'map' } }
+  let(:exhibit) { FactoryBot.create(:exhibit) }
+  let(:tags) { %w[hello world] }
+
+  before do
+    allow(Spotlight::Engine.config).to receive_messages(bulk_actions_batch_size: 5)
+  end
+
+  it 'removes tags from SolrDocumentSidecar objects' do
+    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
+    expect(response.total).to eq 55
+    response.documents.each do |document|
+      exhibit.tag(document.sidecar(exhibit), with: %w[hello world], on: :tags)
+      document.reindex
+    end
+    subject.perform_now
+    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
+    expect(response.total).to eq 55
+    expect(Spotlight::JobTracker.last).to have_attributes(
+      status: 'completed',
+      total: 55,
+      progress: 55,
+      job_class: 'Spotlight::RemoveTagsJob'
+    )
+    response.documents.each do |document|
+      expect(document.sidecar(exhibit).all_tags_list).to eq []
+    end
+    exhibit.owned_tags.destroy_all
+    response.documents.each do |document|
+      document.sidecar(exhibit).destroy
+      document.reindex
+    end
+  end
+end

data/spec/lib/migration/iiif_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe Migration::IIIF do
     context "when it's any FeaturedImage" do
       it 'updates the iiif_tilesource attribute based on the given host and image resource' do
         instance.run
-        expect(updated_thumb.iiif_tilesource).to eq "http://test.host/images/#{updated_thumb.id}/info.json"
+        expect(updated_thumb.iiif_tilesource).to match %r{http://test.host/images/#{updated_thumb.id}-.*/info.json}
       end
 
       it 'returns a nil region if one was not set' do

data/spec/mailers/spotlight/indexing_complete_mailer_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 describe Spotlight::IndexingCompleteMailer do
-  subject { described_class.documents_indexed [1, 2, 3], exhibit, user }
+  subject { described_class.documents_indexed [1, 2, 3], exhibit, user, indexed_count: 3 }
 
   let(:user) { double(email: 'test@example.com') }
   let(:exhibit) { double(title: 'Exhibit title') }
@@ -29,4 +29,14 @@ describe Spotlight::IndexingCompleteMailer do
   it 'includes the exhibit title' do
     expect(subject.body.encoded).to match exhibit.title
   end
+
+  context 'with errors' do
+    subject { described_class.documents_indexed [], exhibit, user, indexed_count: 0, errors: { 1 => ['missing title'], 20 => ['whatever'] } }
+
+    it 'includes some errors' do
+      expect(subject.body.encoded).to match 'Errors'
+      expect(subject.body.encoded).to match 'Row 1: missing title'
+      expect(subject.body.encoded).to match 'Row 20: whatever'
+    end
+  end
 end

data/spec/models/sir_trevor_rails/blocks/browse_group_categories_block_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+describe SirTrevorRails::Blocks::BrowseGroupCategoriesBlock do
+  subject { described_class.new({ type: '', data: block_data }, page) }
+
+  let!(:exhibit) { FactoryBot.create(:exhibit) }
+  let!(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
+  let!(:group1) { FactoryBot.create(:group, exhibit: exhibit, title: 'abc123', published: true) }
+  let!(:group2) { FactoryBot.create(:group, exhibit: exhibit, title: 'xyz321', published: true) }
+
+  let(:block_data) { {} }
+
+  describe '#groups' do
+    it 'is the array of items with display set to true' do
+      block_data[:item] = {
+        '0': { id: 'abc123', display: 'true', weight: '2' },
+        '1': { id: 'xyz321', display: 'true', weight: '1' }
+      }
+      expect(subject.groups.length).to eq 2
+      expect(subject.groups.first.title).to eq 'xyz321'
+    end
+  end
+
+  describe '#groups?' do
+    it 'is the array of items with display set to true' do
+      block_data[:item] = {}
+      expect(subject.be_groups).to be_falsy
+    end
+  end
+
+  describe '#display_item_counts?' do
+    it do
+      expect(subject).not_to be_display_item_counts
+    end
+
+    it do
+      block_data['display-item-counts'] = 'true'
+      expect(subject).to be_display_item_counts
+    end
+  end
+end

data/spec/models/solr_document_spec.rb

@@ -4,14 +4,13 @@ describe SolrDocument, type: :model do
   subject { document }
 
   let(:document) { described_class.new(id: 'abcd123') }
+  let(:exhibit_alt) { FactoryBot.create(:exhibit) }
+  let(:exhibit) { FactoryBot.create(:exhibit) }
 
   before do
     allow(subject).to receive_messages(reindex: nil)
   end
 
-  let(:exhibit_alt) { FactoryBot.create(:exhibit) }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
   its(:to_key) { is_expected.to eq ['abcd123'] }
   its(:persisted?) { is_expected.to be_truthy }
 

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

@@ -3,6 +3,7 @@
 describe Spotlight::AccessControlsEnforcementSearchBuilder do
   class MockSearchBuilder < Blacklight::SearchBuilder
     attr_reader :blacklight_params, :scope
+
     def initialize(blacklight_params, scope)
       @blacklight_params = blacklight_params
       @scope = scope

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