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

data/spec/helpers/spotlight/crud_link_helpers_spec.rb

@@ -104,7 +104,7 @@ describe Spotlight::CrudLinkHelpers, type: :helper do
   describe '#action_default_value' do
     it 'attempts i18n lookups for models' do
       expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.edit',
-                                       model: some_model.class.model_name.human,
+                                       model: some_model.class.model_name.human.downcase,
                                        default: [:'helpers.action.edit', 'Edit Feature page'])
       expect(helper.send(:action_default_value, some_model))
     end
@@ -112,14 +112,14 @@ describe Spotlight::CrudLinkHelpers, type: :helper do
     it 'attempts i18n lookups for unpersisted models' do
       some_model = Spotlight::FeaturePage.new
       expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.create',
-                                       model: some_model.class.model_name.human,
+                                       model: some_model.class.model_name.human.downcase,
                                        default: [:'helpers.action.create', 'Create Feature page'])
       expect(helper.send(:action_default_value, some_model))
     end
 
     it 'attempts i18n lookups for models with an explicit action' do
       expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.custom_action',
-                                       model: some_model.class.model_name.human,
+                                       model: some_model.class.model_name.human.downcase,
                                        default: [:'helpers.action.custom_action', 'Custom action Feature page'])
       expect(helper.send(:action_default_value, some_model, :custom_action))
     end

data/spec/helpers/spotlight/pages_helper_spec.rb

@@ -106,16 +106,24 @@ 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
-    context 'with a sir-trevor backed page' do
+    context 'a sir-trevor backed page with a custom class' do
       it 'has a custom class' do
         expect(helper.content_editor_class(Spotlight::Page.new)).to eq 'js-st-instance'
       end
     end
 
-    context 'with a sir-trevor backed page' do
+    context 'a sir-trevor backed page with a derived class' do
       it 'derives a css class name from the editor type' do
         expect(helper.content_editor_class(Spotlight::Page.new(content_type: 'Something::Custom'))).to eq 'js-something-custom-instance'
       end

data/spec/i18n_spec.rb

@@ -2,7 +2,6 @@
 
 require 'i18n/tasks'
 
-# rubocop:disable RSpec/DescribeClass
 RSpec.describe 'I18n' do
   let(:i18n) { I18n::Tasks::BaseTask.new }
   let(:missing_keys) { i18n.missing_keys }
@@ -26,4 +25,3 @@ RSpec.describe 'I18n' do
     expect(non_normalized).to be_empty, error_message
   end
 end
-# rubocop:enable RSpec/DescribeClass

data/spec/jobs/spotlight/add_uploads_from_csv_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Spotlight::AddUploadsFromCSV do
+describe Spotlight::AddUploadsFromCsv do
   subject(:job) { described_class.new(data, exhibit, user) }
 
   let(:exhibit) { FactoryBot.create(:exhibit) }
@@ -40,4 +40,16 @@ describe Spotlight::AddUploadsFromCSV do
 
     job.perform_now
   end
+
+  context 'with errors' do
+    it 'collects errors uploaded resources for each row of data' do
+      allow(Spotlight::IndexingCompleteMailer).to receive(:documents_indexed).and_return(double(deliver_now: true))
+      job.perform_now
+      expect(Spotlight::IndexingCompleteMailer).to have_received(:documents_indexed).with(
+        data, exhibit, user,
+        indexed_count: 1,
+        errors: { 1 => array_including(match(/relative URI: x/)), 2 => array_including(match(/Upload is invalid/)) }
+      )
+    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,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/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/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/exhibit_spec.rb

@@ -19,6 +19,14 @@ describe Spotlight::Exhibit, type: :model do
     expect(subject.description).to eq 'Test description'
   end
 
+  it 'has reserved slugs' do
+    subject.slug = 'site'
+
+    expect do
+      subject.save!
+    end.to raise_error(ActiveRecord::RecordInvalid, 'Validation failed: Slug is reserved')
+  end
+
   describe 'validations' do
     it 'validates the presence of the title' do
       exhibit.title = ''
@@ -28,7 +36,7 @@ describe Spotlight::Exhibit, type: :model do
     end
 
     it 'does not validate the presence of the title under a non-default locale' do
-      expect(I18n).to receive(:locale).and_return(:fr)
+      allow(I18n).to receive(:locale).and_return(:fr)
       exhibit.title = ''
       expect do
         exhibit.save
@@ -147,7 +155,7 @@ describe Spotlight::Exhibit, type: :model do
     it 'removes the default browse category' do
       subject.save
       expect { subject.import({}) }.to change { subject.searches.count }.by(0)
-      expect { subject.import('searches' => [{ 'title' => 'All Exhibit Items', 'slug' => 'all-exhibit-items' }]) }.to change { subject.searches.count }.by(0)
+      expect { subject.import('searches' => [{ 'title' => 'All exhibit items', 'slug' => 'all-exhibit-items' }]) }.to change { subject.searches.count }.by(0)
     end
 
     it 'imports nested attributes from the hash' do
@@ -245,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
 
@@ -358,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
 
@@ -402,6 +356,7 @@ describe Spotlight::Exhibit, type: :model do
       I18n.locale = 'fr'
       persisted_exhibit.reload
       expect(persisted_exhibit.title).to eq 'Titre français'
+      expect(persisted_exhibit.translated_title).to eq 'Titre français'
     end
 
     it 'has a translatable subtitle' do
@@ -417,5 +372,12 @@ describe Spotlight::Exhibit, type: :model do
       persisted_exhibit.reload
       expect(persisted_exhibit.description).to eq 'Description français'
     end
+
+    it 'is nil if no translation has been prrovided' do
+      expect(persisted_exhibit.title).to eq 'Sample'
+      I18n.locale = 'es'
+      persisted_exhibit.reload
+      expect(persisted_exhibit.translated_title(default: '')).to eq nil
+    end
   end
 end