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

data/spec/models/spotlight/resources/iiif_harvester_spec.rb

@@ -3,12 +3,11 @@
 require 'spec_helper'
 
 describe Spotlight::Resources::IiifHarvester do
+  subject(:harvester) { described_class.create(exhibit_id: exhibit.id, url: url) }
+
   let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:harvester) { described_class.create(exhibit_id: exhibit.id, url: url) }
 
   describe 'Validation' do
-    subject { harvester }
-
     context 'when given an invalid URL' do
       before do
         stub_request(:head, 'http://example.com').to_return(status: 200, headers: { 'Content-Type' => 'text/html' })
@@ -38,16 +37,16 @@ describe Spotlight::Resources::IiifHarvester do
     end
   end
 
-  describe '#documents_to_index' do
-    subject { harvester.document_builder }
-
+  describe '#reindex' do
     let(:url) { 'uri://for-top-level-collection' }
 
-    before { stub_default_collection }
+    before do
+      stub_default_collection
+      allow(Spotlight::Engine.config).to receive(:writable_index).and_return(false)
+    end
 
-    it 'returns an Enumerator of all the solr documents' do
-      expect(subject.documents_to_index).to be_a(Enumerator)
-      expect(subject.documents_to_index.count).to eq 8
+    it 'indexes all the solr documents' do
+      expect(subject.reindex).to eq 8
     end
   end
 end

data/spec/models/spotlight/resources/upload_spec.rb

@@ -1,107 +1,71 @@
 # frozen_string_literal: true
 
 describe Spotlight::Resources::Upload, type: :model do
-  let!(:exhibit) { FactoryBot.create :exhibit }
-  let!(:custom_field) { FactoryBot.create :custom_field, exhibit: exhibit }
-  let(:resource) { described_class.new(exhibit: exhibit) }
-  let(:doc_builder) { resource.document_builder }
+  subject(:upload) { described_class.new(id: 42, exhibit: exhibit) }
 
-  let(:configured_fields) { [title_field] + described_class.fields(exhibit) }
-  let(:title_field) { Spotlight::UploadFieldConfig.new(field_name: 'configured_title_field') }
-  let(:upload_data) do
-    {
-      title_field.field_name => 'Title Data',
-      'spotlight_upload_description_tesim' => 'Description Data',
-      'spotlight_upload_attribution_tesim' => 'Attribution Data',
-      'spotlight_upload_date_tesim' => 'Date Data',
-      custom_field.slug => 'Custom Field Data'
-    }
-  end
-  let(:featured_image) { FactoryBot.create(:featured_image, image: File.open(File.join(FIXTURES_PATH, '800x600.png'))) }
-
-  before do
-    Rails.cache.clear # wipes out any cached image info.
-    allow(resource).to receive(:configured_fields).and_return configured_fields
-    allow(described_class).to receive(:fields).and_return configured_fields
-
-    allow(resource.send(:blacklight_solr)).to receive(:update)
-    allow(Spotlight::Engine.config).to receive(:upload_title_field).and_return(title_field)
-    resource.data = upload_data
-    resource.upload = featured_image
-    resource.save
-  end
+  let(:exhibit) { FactoryBot.create(:exhibit) }
 
-  context 'with a custom upload title field' do
-    subject { doc_builder.to_solr }
-
-    let(:title_field) { Spotlight::UploadFieldConfig.new(field_name: 'configured_title_field', solr_fields: [:some_other_field]) }
+  describe '.fields' do
+    it "includes the exhibit's uploaded resource fields" do
+      expect(described_class.fields(exhibit)).to include(*exhibit.uploaded_resource_fields)
+    end
 
-    describe '#to_solr' do
-      it 'stores the title field in the provided solr field' do
-        expect(subject[:some_other_field]).to eq 'Title Data'
+    context 'title field' do
+      it 'is an UploadFieldConfig object for the configured index title_field' do
+        upload_config = described_class.fields(exhibit).first
+        expect(upload_config).to be_a Spotlight::UploadFieldConfig
+        expect(upload_config.field_name).to eq exhibit.blacklight_config.index.title_field
       end
     end
   end
 
-  context 'multiple solr field mappings' do
-    let :configured_fields do
-      [
-        Spotlight::UploadFieldConfig.new(field_name: 'some_field', solr_fields: %w[a b])
-      ]
-    end
-
-    let :upload_data do
-      { 'some_field' => 'value' }
+  describe '#compound_id' do
+    it 'appends the object ID w/ the exhibit ID' do
+      expect(upload.compound_id).to eq "#{exhibit.id}-42"
     end
+  end
 
-    describe '#to_solr' do
-      subject { doc_builder.to_solr }
+  describe '#sidecar' do
+    it 'is a SolrDocumentSidecar with the correct relationships' do
+      sidecar = upload.sidecar
 
-      it 'maps a single uploaded field to multiple solr fields' do
-        expect(subject).not_to include 'some_field'
-        expect(subject['a']).to eq 'value'
-        expect(subject['b']).to eq 'value'
-      end
+      expect(sidecar).to be_a Spotlight::SolrDocumentSidecar
+      expect(sidecar.exhibit_id).to eq exhibit.id
+      expect(sidecar.document_id).to eq "#{exhibit.id}-42"
     end
   end
 
-  describe '#to_solr' do
-    subject { doc_builder.to_solr }
-
-    it 'has the exhibit id and the upload id as the solr id' do
-      expect(subject[:id]).to eq "#{resource.exhibit.id}-#{resource.id}"
+  context 'when creating' do
+    before do
+      allow(upload).to receive(:write?).and_return(false)
     end
 
-    it 'has a title field using the exhibit specific blacklight_config' do
-      expect(subject['configured_title_field']).to eq 'Title Data'
-    end
+    it 'the sidecar is updated with the apporpriate data from configured fields' do
+      expect(upload.sidecar).to receive(:update).with(
+        data: {
+          'configured_fields' => {
+            'full_title_tesim' => 'My Upload Title',
+            'spotlight_upload_date_tesim' => 'My Upload Date'
+          }
+        }
+      )
 
-    it 'has the other additional configured fields' do
-      expect(subject[:spotlight_upload_description_tesim]).to eq 'Description Data'
-      expect(subject[:spotlight_upload_attribution_tesim]).to eq 'Attribution Data'
-      expect(subject[:spotlight_upload_date_tesim]).to eq 'Date Data'
-    end
+      upload.data = { 'full_title_tesim' => 'My Upload Title', 'spotlight_upload_date_tesim' => 'My Upload Date' }
 
-    it 'has a spotlight_resource_type field' do
-      expect(subject[:spotlight_resource_type_ssim]).to eq 'spotlight/resources/uploads'
+      upload.save
     end
 
-    it 'has the various image fields' do
-      expect(subject).to have_key Spotlight::Engine.config.thumbnail_field
-    end
+    it 'the sidecar is updated with the appropriate data from custom fields' do
+      FactoryBot.create(:custom_field, exhibit: exhibit, slug: 'custom_field_1')
+      FactoryBot.create(:custom_field, exhibit: exhibit, slug: 'custom_field_2')
 
-    it 'has the full image dimensions fields' do
-      expect(subject[:spotlight_full_image_height_ssm]).to eq 600
-      expect(subject[:spotlight_full_image_width_ssm]).to eq 800
-    end
+      expect(upload.sidecar).to receive(:update).with(
+        data: hash_including('custom_field_1' => 'Custom Field 1 Data', 'custom_field_2' => 'Custom Field 2 Data')
+      )
 
-    it 'has fields representing exhibit specific custom fields' do
-      expect(subject[custom_field.solr_field]).to eq 'Custom Field Data'
-    end
+      upload.data = { 'custom_field_1' => 'Custom Field 1 Data', 'custom_field_2' => 'Custom Field 2 Data' }
 
-    it 'has a field for the iiif manifest url' do
-      manifest_path = Spotlight::Engine.routes.url_helpers.manifest_exhibit_solr_document_path(exhibit, resource.compound_id)
-      expect(subject[Spotlight::Engine.config.iiif_manifest_field]).to eq(manifest_path)
+      upload.save
     end
   end
 end

data/spec/models/spotlight/role_spec.rb

@@ -9,7 +9,7 @@ describe Spotlight::Role, type: :model do
 
       it 'does not be valid' do
         expect(subject).not_to be_valid
-        expect(subject.errors.messages).to include(role: ['is not included in the list'], 'user.email': ["can't be blank"])
+        expect(subject.errors.messages.transform_values(&:to_a)).to include(role: ['is not included in the list'], 'user.email': ["can't be blank"])
       end
     end
 
@@ -37,10 +37,10 @@ describe Spotlight::Role, type: :model do
 
       describe 'that points at a user with an existing role' do
         let(:user) { FactoryBot.create(:user) }
-        before { described_class.create!(role: 'curator', user: user) }
-
         let(:args) { { role: 'curator', user_key: user.email } }
 
+        before { described_class.create!(role: 'curator', user: user) }
+
         it 'is valid' do
           expect(subject).not_to be_valid
           expect(subject.errors.messages).to eq(user_key: ['already a member of this exhibit'])

data/spec/models/spotlight/search_spec.rb

@@ -5,7 +5,7 @@ describe Spotlight::Search, type: :model do
 
   let(:exhibit) { FactoryBot.create(:exhibit) }
 
-  let(:query_params) { { 'f' => { 'genre_sim' => ['map'] } } }
+  let(:query_params) { { 'f' => { 'genre_ssim' => ['map'] } } }
 
   let(:blacklight_config) { ::CatalogController.blacklight_config }
   let(:document) do
@@ -17,7 +17,10 @@ describe Spotlight::Search, type: :model do
     let(:query_params) { {} }
 
     it 'has items' do
-      expect(subject.documents.size).to eq 55
+      # Add some fuzziness to this. Running locally it should be 55 but in some
+      # CI environments, spec/features/add_items_spec.rb will end up adding new
+      # records and cannot ensure deletion of them.
+      expect(subject.documents.size).to be_within(1).of(55)
     end
   end
 
@@ -31,6 +34,16 @@ describe Spotlight::Search, type: :model do
     end
   end
 
+  describe '.unpublished' do
+    let!(:search1) { FactoryBot.create(:search, published: true) }
+    let!(:search2) { FactoryBot.create(:search, published: false) }
+    let!(:search3) { FactoryBot.create(:search, published: nil) }
+
+    it 'accounts for nil and false values' do
+      expect(described_class.unpublished.count).to eq 5
+    end
+  end
+
   describe '#slug' do
     let(:search) { FactoryBot.create(:search) }
 
@@ -54,7 +67,7 @@ describe Spotlight::Search, type: :model do
 
   describe '#search_params' do
     it 'maps the search to the appropriate facet values' do
-      expect(subject.search_params.to_hash).to include 'fq' => array_including('{!term f=genre_sim}map')
+      expect(subject.search_params.to_hash).to include 'fq' => array_including('{!term f=genre_ssim}map')
     end
 
     context 'with filter_resources_by_exhibit configured' do
@@ -95,4 +108,18 @@ describe Spotlight::Search, type: :model do
       expect(search_params).to include user_params
     end
   end
+
+  describe '#groups' do
+    let(:search) { FactoryBot.create(:search_with_groups, groups_count: 3) }
+
+    it do
+      expect(search.groups.count).to eq 3
+    end
+
+    it do
+      search.groups.all do |group|
+        expect(group).to be_an Spotlight::Group
+      end
+    end
+  end
 end

data/spec/models/spotlight/solr_document_sidecar_spec.rb

@@ -20,6 +20,7 @@ describe Spotlight::SolrDocumentSidecar, type: :model do
     context 'with an uploaded item' do
       before do
         subject.data = { 'configured_fields' => { 'some_configured_field' => 'some value' } }
+        subject.resource = Spotlight::Resources::Upload.new
         allow(Spotlight::Resources::Upload).to receive(:fields).with(exhibit).and_return([uploaded_field_config])
       end
 

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::Context do
+  subject(:context) { described_class.new(resource, **context_args) }
+
+  let(:resource) { instance_double(Spotlight::Resource, id: 123, document_model: SolrDocument) }
+  let(:context_args) { {} }
+
+  describe '#resource' do
+    it 'extracts the Spotlight::Resource from the argument list' do
+      expect(context.resource).to eq resource
+    end
+  end
+
+  describe '#unique_key' do
+    let(:data) { { id: '123' } }
+
+    it 'tries to get a usable unique key for a transformed document' do
+      expect(context.unique_key(data)).to eq '123'
+    end
+  end
+
+  describe '#on_error' do
+    context 'with a class-level handler' do
+      let(:handler) { instance_double(Proc, call: nil) }
+
+      it 'calls the class-level handler' do
+        allow(described_class).to receive(:error_reporter).and_return(handler)
+
+        subject.on_error(nil, nil, {})
+
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'with an instance-level handler' do
+      let(:context_args) { { on_error: handler } }
+      let(:handler) { instance_double(Proc, call: nil) }
+
+      it 'calls the instance-level handler' do
+        subject.on_error(nil, nil, {})
+
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'with :log' do
+      it 'logs an error' do
+        allow(Rails.logger).to receive(:error)
+
+        subject.on_error(nil, nil, {})
+
+        expect(Rails.logger).to have_received(:error).with(/Pipeline error/)
+      end
+    end
+
+    context 'with :exception' do
+      let(:context_args) { { on_error: :exception } }
+      let(:e) { StandardError.new('asdf') }
+
+      it 'raises an exception' do
+        expect { subject.on_error(nil, e, {}) }.to raise_exception(e)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+describe Spotlight::Etl::Executor do
+  subject(:executor) { described_class.new(pipeline, context) }
+
+  let(:pipeline) do
+    Spotlight::Etl::Pipeline.new do |pipeline|
+      pipeline.sources = [Spotlight::Etl::Sources::IdentitySource]
+      pipeline.transforms = [Spotlight::Etl::Transforms::IdentityTransform]
+      pipeline.loaders = [->(result, *) { arr << result }]
+    end
+  end
+  let(:context) { Spotlight::Etl::Context.new(resource) }
+  let(:resource) { Spotlight::Resource.new }
+  let(:arr) { [] }
+
+  describe '#call' do
+    it 'provides the context to the sources' do
+      pipeline.sources = [->(context, *) { [{ context: context }] }]
+
+      executor.call
+
+      expect(arr).to eq [{ context: context }]
+    end
+
+    it 'makes the current source available to transforms' do
+      pipeline.transforms = [->(_data, pipeline) { pipeline.source }]
+
+      executor.call
+
+      expect(arr).to eq [resource]
+    end
+
+    it 'chains the calls to the transforms' do
+      pipeline.transforms = [
+        ->(data, *) { data.merge(a: 1) },
+        ->(data, *) { data.merge(b: 2) },
+        ->(data, *) { data.merge(c: 3) }
+      ]
+
+      executor.call
+
+      expect(arr).to eq [{ a: 1, b: 2, c: 3 }]
+    end
+
+    it 'caches the step instances across sources' do
+      pipeline.sources = [->(*) { [1, 2, 3] }]
+
+      pipeline.transforms = [
+        Class.new do
+          def initialize
+            @sum = 0
+          end
+
+          def call(data, pipeline)
+            @sum += pipeline.source
+
+            data.merge(sum: @sum)
+          end
+        end
+      ]
+
+      executor.call
+
+      expect(arr).to eq [{ sum: 1 }, { sum: 3 }, { sum: 6 }]
+    end
+
+    it 'loads resulting documents' do
+      loader = Spotlight::Etl::SolrLoader.new
+      pipeline.sources = [->(*) { [{}, {}, {}] }]
+      pipeline.loaders = [loader]
+
+      allow(loader).to receive(:call)
+
+      executor.call
+
+      expect(loader).to have_received(:call).exactly(3).times
+    end
+
+    it 'allows steps to throw :skip to skip the current source' do
+      pipeline.pre_processes = [
+        ->(*) { throw(:skip) }
+      ]
+
+      executor.call
+
+      expect(arr).to be_blank
+    end
+
+    it 'forwards errors to the context error handler' do
+      e = StandardError.new
+      pipeline.transforms = [->(*) { raise e }]
+
+      allow(context).to receive(:on_error)
+      executor.call
+
+      expect(context).to have_received(:on_error).with(executor, e, {})
+    end
+
+    context 'after processing the data' do
+      it 'calls finalize on the loaders' do
+        loader = Spotlight::Etl::SolrLoader.new
+        pipeline.sources = [->(*) { [{}, {}, {}] }]
+        pipeline.loaders = [loader]
+
+        allow(loader).to receive(:call)
+        allow(loader).to receive(:finalize)
+
+        executor.call
+
+        expect(loader).to have_received(:call).exactly(3).times
+        expect(loader).to have_received(:finalize).once
+      end
+
+      it 'resets the step cache' do
+        pipeline.transforms = [
+          Class.new do
+            def initialize
+              @count = 0
+            end
+
+            def call(data, *)
+              @count += 1
+
+              data.merge(count: @count)
+            end
+          end
+        ]
+
+        executor.call
+        executor.call
+
+        expect(arr).to eq [{ count: 1 }, { count: 1 }]
+      end
+    end
+  end
+
+  describe '#estimated_size' do
+    let(:source) { ->(*) { [1, 2, 3, 4] } }
+
+    before do
+      pipeline.sources = [source]
+    end
+
+    it 'estimates the final size from the sources' do
+      expect(executor.estimated_size).to eq 4
+    end
+  end
+end