blacklight-spotlight 3.0.0.rc3 → 3.0.0.rc4

data/spec/factories/job_trackers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :job_tracker, class: 'Spotlight::JobTracker' do
+    user
+    created_at { Time.zone.parse('2017-01-05 23:00:00') }
+    updated_at { Time.zone.parse('2017-01-05 23:05:00') }
+  end
+end

data/spec/features/add_items_spec.rb

@@ -43,7 +43,8 @@ describe 'Uploading a non-repository item', type: :feature do
       expect(page).to have_content 'Object uploaded successfully.'
 
       expect(Spotlight::Resource.last.upload.image.file.path).to end_with '800x600.png'
-      Blacklight.default_index.connection.delete_by_id Spotlight::Resource.last.send(:compound_id)
+    ensure
+      Blacklight.default_index.connection.delete_by_query 'spotlight_resource_type_ssim:spotlight/resources/uploads'
       Blacklight.default_index.connection.commit
     end
 
@@ -59,8 +60,8 @@ describe 'Uploading a non-repository item', type: :feature do
       end
       expect(page).to have_content 'Object uploaded successfully.'
       expect(Spotlight::Resource.last.data['full_title_tesim']).to eq 'no-image'
-
-      Blacklight.default_index.connection.delete_by_id Spotlight::Resource.last.send(:compound_id)
+    ensure
+      Blacklight.default_index.connection.delete_by_query 'spotlight_resource_type_ssim:spotlight/resources/uploads'
       Blacklight.default_index.connection.commit
     end
 
@@ -113,6 +114,9 @@ describe 'Uploading a non-repository item', type: :feature do
         end
       end
 
+      Blacklight.default_index.connection.commit
+      visit current_path
+
       click_link '800x600'
       click_link 'Edit'
       fill_in 'Title', with: 'This is a now an avatar'
@@ -123,7 +127,8 @@ describe 'Uploading a non-repository item', type: :feature do
 
       expect(page).to have_content 'This is a now an avatar'
       expect(Spotlight::Resource.last.upload.image.path).to end_with 'avatar.png'
-      Blacklight.default_index.connection.delete_by_id Spotlight::Resource.last.send(:compound_id)
+    ensure
+      Blacklight.default_index.connection.delete_by_query 'spotlight_resource_type_ssim:spotlight/resources/uploads'
       Blacklight.default_index.connection.commit
     end
   end

data/spec/features/javascript/reindex_monitor_spec.rb

@@ -8,7 +8,7 @@ describe 'Reindex Monitor', js: true, default_max_wait_time: 10 do
   let(:exhibit_curator) { FactoryBot.create(:exhibit_curator, exhibit: exhibit) }
 
   before do
-    FactoryBot.create(:in_progress_reindexing_log_entry, exhibit: exhibit, items_reindexed_estimate: 5)
+    exhibit.job_trackers.create(resource: exhibit, status: 'completed', job_class: 'Spotlight::ReindexExhibitJob')
     login_as exhibit_curator
     visit spotlight.admin_exhibit_catalog_path(exhibit)
   end

data/spec/features/site_users_management_spec.rb

@@ -44,13 +44,13 @@ describe 'Site users management', js: true do
 
     expect(page).to have_css(:td, text: 'not-an-admin@example.com')
 
-    expect(page).to have_css(:a, text: 'Remove from admin role', count: 4)
+    expect(page).to have_css(:a, text: 'Remove from admin role', count: 2)
     within(all('table tbody tr:not([data-edit-for])').last) do
       click_link 'Remove from admin role'
     end
 
     expect(page).to have_content 'User removed from site adminstrator role'
-    expect(page).to have_css(:a, text: 'Remove from admin role', count: 2)
+    expect(page).to have_css(:a, text: 'Remove from admin role', count: 0)
   end
 
   it 'sends an invitation email to users who do not exist' do
@@ -68,7 +68,7 @@ describe 'Site users management', js: true do
     click_link 'Add new administrator'
 
     expect(page).to have_css('td', text: user.email)
-    # There are two users, the original site admin and our admin user so only one button
-    expect(page).to have_css(:a, text: 'Remove from admin role', count: 2)
+    # There is just our admin user so no button
+    expect(page).to have_css(:a, text: 'Remove from admin role', count: 0)
   end
 end

data/spec/helpers/spotlight/pages_helper_spec.rb

@@ -106,6 +106,14 @@ describe Spotlight::PagesHelper, type: :helper do
     it 'handles nil input' do
       expect(helper.sir_trevor_markdown(nil)).to be_blank
     end
+
+    it 'retains paragraphs' do
+      expect(helper.sir_trevor_markdown('<p>First Line</p><p>Second Line</p>').chomp).to match(%r{<p>First Line</p>\s*<p>Second Line</p>})
+    end
+
+    it 'replaces line breaks with paragraphs' do
+      expect(helper.sir_trevor_markdown('First Line<br>Second Line').chomp).to match(%r{<p>First Line</p>\s*<p>Second Line</p>})
+    end
   end
 
   describe '#content_editor_class' do

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,14 @@ 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) }
 
@@ -75,31 +22,55 @@ describe Spotlight::ReindexJob do
   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/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
     end
   end
 

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