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

data/spec/services/spotlight/etl/pipeline_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::Pipeline do
+  let(:mock_executor) { instance_double(Spotlight::Etl::Executor, call: 'result', estimated_size: 10) }
+  let(:context) { instance_double(Spotlight::Etl::Context) }
+
+  describe '#call' do
+    it 'forwards the call to the executor' do
+      allow(Spotlight::Etl::Executor).to receive(:new).with(subject, context, cache: nil).and_return(mock_executor)
+
+      expect(subject.call(context)).to eq 'result'
+    end
+  end
+
+  describe '#estimated_size' do
+    it 'forwards the call to the executor' do
+      allow(Spotlight::Etl::Executor).to receive(:new).with(subject, context).and_return(mock_executor)
+
+      expect(subject.estimated_size(context)).to eq 10
+    end
+  end
+end

data/spec/services/spotlight/etl/solr_loader_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::SolrLoader do
+  subject(:loader) { described_class.new(batch_size: 5, solr_connection: mock_connection) }
+
+  let(:mock_connection) { instance_double(RSolr::Client, commit: nil, update: nil) }
+
+  describe '#call' do
+    it 'queues data' do
+      loader.call({})
+      loader.call({})
+      loader.call({})
+
+      expect(loader.size).to eq 3
+    end
+
+    it 'writes data to the index when the queue is long enough' do
+      5.times { loader.call({}) }
+
+      expect(mock_connection).to have_received(:update) do |data:, **|
+        expect(JSON.parse(data).length).to eq 5
+      end
+    end
+  end
+
+  describe '#finalize' do
+    let(:pipeline) do
+      Spotlight::Etl::Executor.new(nil, Spotlight::Etl::Context.new(commit: false))
+    end
+
+    it 'flushes the remaining queue to the index' do
+      3.times { loader.call({}) }
+
+      loader.finalize
+
+      expect(mock_connection).to have_received(:update) do |data:, **|
+        expect(JSON.parse(data).length).to eq 3
+      end
+
+      expect(mock_connection).to have_received(:commit)
+    end
+
+    it 'uses the pipeline configuration to determine whether to send a commit' do
+      loader.finalize(pipeline)
+
+      expect(mock_connection).not_to have_received(:commit)
+    end
+
+    context 'error handling' do
+      it 'tries documents individually if the whole batch fails' do
+        allow(mock_connection).to receive(:update) do |data:, **|
+          raise '???' if JSON.parse(data).length > 1
+        end
+
+        3.times { loader.call({}) }
+        loader.finalize
+
+        expect(mock_connection).to have_received(:update).exactly(4).times
+      end
+
+      it 'logs errors from trying individual documents' do
+        allow(pipeline).to receive(:on_error)
+
+        allow(mock_connection).to receive(:update) do |**|
+          raise '???'
+        end
+
+        loader.call({})
+
+        loader.finalize(pipeline)
+
+        expect(pipeline).to have_received(:on_error).once
+      end
+    end
+  end
+end

data/spec/services/spotlight/etl/step_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::Step do
+  subject(:step) { described_class.new(definition, **step_args) }
+
+  let(:definition) { ->(a = nil) { a || 'value' } }
+  let(:step_args) { {} }
+
+  describe '#call' do
+    it 'returns the value from the defined step' do
+      expect(step.call).to eq('value')
+    end
+
+    it 'passes through arguments' do
+      expect(step.call('a')).to eq('a')
+    end
+
+    context 'with a class instance' do
+      let(:definition) { Spotlight::Etl::SolrLoader.new }
+
+      it 'runs the call method' do
+        allow(definition).to receive(:call)
+
+        step.call('a')
+
+        expect(definition).to have_received(:call).with('a')
+      end
+    end
+
+    context 'with a class' do
+      let(:definition) { Spotlight::Etl::SolrLoader }
+      let(:mock) { instance_double(definition, call: nil) }
+
+      it 'runs the call method' do
+        allow(definition).to receive(:new).and_return(mock)
+
+        step.call('a', 'b')
+
+        expect(mock).to have_received(:call).with('a', 'b')
+      end
+
+      it 'uses the same instance for the lifetime of the step' do
+        allow(definition).to receive(:new).once.and_return(mock)
+
+        step.call('a', 'b')
+        step.call('a', 'b')
+
+        expect(mock).to have_received(:call).twice.with('a', 'b')
+      end
+    end
+  end
+
+  describe '#finalize' do
+    it 'does nothing if the definition does not have a #finalize method' do
+      expect { step.finalize }.not_to raise_exception
+    end
+
+    context 'with a loader' do
+      let(:definition) { Spotlight::Etl::SolrLoader.new }
+
+      it 'runs the finalize method' do
+        allow(definition).to receive(:finalize)
+
+        step.finalize
+
+        expect(definition).to have_received(:finalize)
+      end
+    end
+  end
+end

data/spec/{serializers/spotlight/exhibit_export_serializer_spec.rb → services/spotlight/exhibit_import_export_service_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Spotlight::ExhibitExportSerializer do
+describe Spotlight::ExhibitImportExportService do
   subject { JSON.parse(described_class.new(source_exhibit).to_json) }
 
   let!(:source_exhibit) { FactoryBot.create(:exhibit) }
@@ -24,6 +24,10 @@ describe Spotlight::ExhibitExportSerializer do
     expect(subject['searches']).to have(source_exhibit.searches.count).searches
   end
 
+  it 'has group attributes' do
+    expect(subject['groups']).to have(source_exhibit.groups.count).groups
+  end
+
   it 'has home page attributes' do
     expect(subject).to have_key 'home_page'
     expect(subject['home_page']).not_to have_key 'id'
@@ -83,29 +87,43 @@ describe Spotlight::ExhibitExportSerializer do
 
   describe 'should round-trip data' do
     subject do
-      e = FactoryBot.create(:exhibit)
-      e.import(export).tap(&:save)
+      destination_exhibit.import(export)
+      destination_exhibit
     end
 
-    before do
-      sidecar = source_exhibit.solr_document_sidecars.create! document: SolrDocument.new(id: 1), public: false
-      source_exhibit.tag(sidecar, with: 'xyz', on: :tags)
-    end
+    let(:destination_exhibit) { FactoryBot.create(:exhibit) }
 
     let :export do
       described_class.new(source_exhibit).as_json
     end
 
+    before do
+      sidecar = source_exhibit.solr_document_sidecars.create! document: SolrDocument.new(id: 1), public: false
+      source_exhibit.tag(sidecar, with: 'xyz', on: :tags)
+    end
+
     it 'has exhibit properties' do
       expect(subject.title).to eq source_exhibit.title
     end
 
+    context 'with a theme that does not exist in the destination' do
+      it 'ignores the invalid theme' do
+        source_exhibit.theme = 'xyz'
+        expect(subject.theme).to eq nil
+      end
+    end
+
     it 'does not duplicate saved searches' do
       expect(subject.searches).to have(1).item
     end
 
     it 'has blacklight configuration properties' do
+      subject.blacklight_configuration.index_fields_will_change!
+      subject.blacklight_configuration.index_fields['language_ssm'] = { some_value: true }
+      subject.blacklight_configuration.save
+
       expect(subject.blacklight_configuration).to be_persisted
+      expect(subject.blacklight_configuration.blacklight_config.index_fields['language_ssm'].to_h).to include some_value: true
     end
 
     context 'for an exhibit without search fields' do
@@ -221,7 +239,7 @@ describe Spotlight::ExhibitExportSerializer do
       before do
         feature_page.content = { data: [{ type: 'text', data: { text: 'xyz' } }] }.to_json
         feature_page.thumbnail = thumbnail
-        feature_page.save
+        feature_page.save!
       end
 
       it 'copies the masthead' do
@@ -239,6 +257,21 @@ describe Spotlight::ExhibitExportSerializer do
         expect(subject.feature_pages.first.content.length).to eq 1
         expect(subject.feature_pages.first.content.first).to be_a_kind_of SirTrevorRails::Blocks::TextBlock
       end
+
+      context 'with a translation' do
+        before do
+          localized_page = feature_page.clone_for_locale('ar')
+          localized_page.content = { data: [{ type: 'text', data: { text: 'xyz-in-ar' } }] }.to_json
+          localized_page.save!
+        end
+
+        it 'transfers the localized page' do
+          expect(subject.feature_pages.first.translated_pages.length).to eq 1
+          expect(JSON.parse(subject.feature_pages.first.translated_page_for('ar').read_attribute(:content))).to have_key 'data'
+          expect(subject.feature_pages.first.translated_page_for('ar').content.length).to eq 1
+          expect(subject.feature_pages.first.translated_page_for('ar').content.first).to be_a_kind_of SirTrevorRails::Blocks::TextBlock
+        end
+      end
     end
 
     it 'assigns STI resources the correct class' do
@@ -259,19 +292,31 @@ describe Spotlight::ExhibitExportSerializer do
       let(:masthead) { FactoryBot.create(:masthead) }
       let(:thumbnail) { FactoryBot.create(:featured_image) }
       let!(:search) { FactoryBot.create(:search, exhibit: source_exhibit, masthead: masthead, thumbnail: thumbnail) }
+      let!(:existing_search) { FactoryBot.create(:search, slug: search.slug, exhibit: destination_exhibit) }
 
       before do
         source_exhibit.reload
+        destination_exhibit.reload
+      end
+
+      it 'copies the title' do
+        subject
+        existing_search.reload
+        expect(existing_search.title).to eq search.title
       end
 
       it 'copies the masthead' do
-        expect(subject.searches.last.masthead).not_to be_blank
-        expect(subject.searches.last.masthead.image.file.path).not_to eq search.masthead.image.file.path
+        subject
+        existing_search.reload
+        expect(existing_search.masthead).not_to be_blank
+        expect(existing_search.masthead.image.file.path).not_to eq search.masthead.image.file.path
       end
 
       it 'copies the thumbnail' do
-        expect(subject.searches.first.thumbnail).not_to be_blank
-        expect(subject.searches.first.thumbnail.image.file.path).not_to eq search.thumbnail.image.file.path
+        subject
+        existing_search.reload
+        expect(existing_search.thumbnail).not_to be_blank
+        expect(existing_search.thumbnail.image.file.path).not_to eq search.thumbnail.image.file.path
       end
 
       context 'without an attached image' do
@@ -281,8 +326,24 @@ describe Spotlight::ExhibitExportSerializer do
         end
 
         it 'copies the masthead without an image' do
-          expect(subject.searches.last.masthead).not_to be_blank
-          expect(subject.searches.last.masthead.image).to be_blank
+          subject
+          existing_search.reload
+          expect(existing_search.masthead).not_to be_blank
+          expect(existing_search.masthead.image).to be_blank
+        end
+      end
+
+      context 'remote thumbnail with existing tilesource' do
+        it do
+          search.thumbnail.iiif_tilesource
+          search.thumbnail.save
+          source_exhibit.reload
+        end
+
+        it 'unsets the iiif_tilesource' do
+          subject
+          existing_search.reload
+          expect(existing_search.thumbnail.iiif_tilesource).not_to eq search.thumbnail.iiif_tilesource
         end
       end
 
@@ -290,13 +351,44 @@ describe Spotlight::ExhibitExportSerializer do
         before do
           search.masthead.document_global_id = SolrDocument.new(id: 'xyz').to_global_id
           search.masthead.source = 'exhibit'
+          search.masthead.iiif_tilesource = 'foo'
+          search.masthead.image = nil # Setting to nil to mimick an exhibit source
           search.masthead.save
 
           source_exhibit.reload
         end
 
         it 'copies the resource' do
-          expect(subject.searches.last.masthead).not_to be_blank
+          subject
+          existing_search.reload
+          expect(existing_search.masthead).not_to be_blank
+        end
+
+        it 'does not unset the iiif_tilesource' do
+          subject
+          existing_search.reload
+          expect(existing_search.masthead.iiif_tilesource).to eq search.masthead.iiif_tilesource
+        end
+      end
+
+      context 'in a group' do
+        let!(:group) { FactoryBot.create(:group, title: 'blah', exhibit: source_exhibit) }
+
+        before do
+          search.groups << group
+          search.save!
+        end
+
+        it 'copies the group' do
+          subject
+          expect(destination_exhibit.groups.length).to eq 1
+          expect(destination_exhibit.groups.first.as_json).to include(group.as_json.slice('slug', 'title', 'weight', 'published'))
+        end
+
+        it 'copies the group membership' do
+          subject
+          expect(existing_search.reload.groups.length).to eq 1
+          expect(existing_search.groups.pluck(:slug)).to match_array [group.slug]
         end
       end
     end
@@ -328,18 +420,71 @@ describe Spotlight::ExhibitExportSerializer do
     end
   end
 
-  it 'is idempotent-ish' do
-    FactoryBot.create :feature_subpage, exhibit: source_exhibit
-    export = described_class.new(source_exhibit).as_json
-    e = FactoryBot.create(:exhibit)
-    e.import(export).tap(&:save)
-    e.import(export).tap(&:save)
+  context 'testing idempotency' do
+    let(:masthead) { FactoryBot.create(:masthead) }
+    let(:thumbnail) { FactoryBot.create(:exhibit_thumbnail) }
+    let!(:search) { FactoryBot.create(:search, exhibit: source_exhibit, masthead: FactoryBot.create(:masthead), thumbnail: FactoryBot.create(:featured_image)) }
+    let!(:feature_page_1) { FactoryBot.create(:feature_page, exhibit: source_exhibit) }
+    let!(:feature_page_2) { FactoryBot.create(:feature_page, exhibit: source_exhibit) }
+
+    before do
+      source_exhibit.masthead = masthead
+      source_exhibit.thumbnail = thumbnail
+    end
+
+    # From Rails 6:
+    def _deep_transform_values_in_object(object, &block)
+      case object
+      when Hash
+        object.transform_values { |value| _deep_transform_values_in_object(value, &block) }
+      when Array
+        object.map { |e| _deep_transform_values_in_object(e, &block) }
+      else
+        yield(object)
+      end
+    end
+
+    it 'is re-runnable' do
+      FactoryBot.create :feature_subpage, exhibit: source_exhibit
+      export = described_class.new(source_exhibit).as_json
+      e = FactoryBot.create(:exhibit)
+      e.import(export)
+      e.import(export)
+    end
+
+    it 'is idempotent-ish' do
+      export = described_class.new(source_exhibit).as_json
+      e = FactoryBot.create(:exhibit)
+      e.import(export)
+      new_export = described_class.new(e).as_json
+
+      actual = _deep_transform_values_in_object(new_export) do |v|
+        if DateTime.parse(v.to_s)
+          nil
+        else
+          v
+        end
+      rescue ArgumentError
+        nil
+      end
+      expected = _deep_transform_values_in_object(export) do |v|
+        if DateTime.parse(v.to_s)
+          nil
+        else
+          v
+        end
+      rescue ArgumentError
+        nil
+      end
+      expect(actual).to include expected
+    end
   end
 
   describe 'should export saved searches with query parameters that can be re-generated' do
     subject do
       e = FactoryBot.create(:exhibit)
-      e.import(export).tap(&:save)
+      e.import(export)
+      e
     end
 
     before do
@@ -418,7 +563,7 @@ describe Spotlight::ExhibitExportSerializer do
     end
 
     it 'includes only the page-related data' do
-      expect(subject.keys).to match_array %w[searches about_pages feature_pages home_page contacts]
+      expect(subject.keys).to match_array %w[searches groups about_pages feature_pages home_page contacts]
     end
   end
 end