blacklight-spotlight 3.4.0 → 3.4.1

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

@@ -1,22 +0,0 @@
-# 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, any_args).and_return(mock_executor)
-
-      expect(subject.estimated_size(context)).to eq 10
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# 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