blacklight-spotlight 3.4.0 → 3.4.1

data/spec/helpers/spotlight/navbar_helper_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::NavbarHelper, type: :helper do
-  describe '#should_render_search_bar?' do
-    before do
-      allow(helper).to receive_messages(current_exhibit: nil)
-      allow(helper).to receive_messages(exhibit_masthead?: true)
-    end
-
-    it 'returns false when there is no exhibit context' do
-      expect(helper).not_to be_should_render_spotlight_search_bar
-    end
-
-    it 'returns true if searchable' do
-      allow(helper).to receive_messages(current_exhibit: double(searchable?: true))
-      expect(helper).to be_should_render_spotlight_search_bar
-    end
-
-    it 'returns false if currently under an "Exhibity" browse category' do
-      allow(helper).to receive_messages(exhibit_masthead?: false)
-      expect(helper).not_to be_should_render_spotlight_search_bar
-    end
-  end
-end

data/spec/helpers/spotlight/pages_helper_spec.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::PagesHelper, type: :helper do
-  let(:blacklight_config) { Blacklight::Configuration.new { |config| config.show.title_field = :abc } }
-  let(:titled_document) { blacklight_config.document_model.new(abc: 'value') }
-  let(:untitled_document) { blacklight_config.document_model.new(id: '1234') }
-  let!(:current_exhibit) { FactoryBot.create(:exhibit) }
-  let!(:home_page) { current_exhibit.home_page }
-  let!(:search) { FactoryBot.create(:search, exhibit: current_exhibit, query_params: { 'q' => 'query' }, published: true) }
-
-  before do
-    allow(helper).to receive_messages(blacklight_config: blacklight_config)
-  end
-
-  describe 'disable_save_pages_button?' do
-    it 'returns true if there are no pages and we are on the about pages page' do
-      expect(helper).to receive(:page_collection_name).and_return('about_pages')
-      assign(:pages, [])
-      expect(helper).to be_disable_save_pages_button
-    end
-
-    it 'returns false if there are about pages' do
-      expect(helper).to receive(:page_collection_name).and_return('about_pages')
-      assign(:pages, [{}])
-      expect(helper).not_to be_disable_save_pages_button
-    end
-
-    it 'returns false if on the feature pages page' do
-      expect(helper).to receive(:page_collection_name).and_return('feature_pages')
-      assign(:pages, [])
-      expect(helper).not_to be_disable_save_pages_button
-    end
-  end
-
-  describe 'get_search_widget_search_results' do
-    let(:good) do
-      content = { type: 'xyz', data: { 'item' => { search.slug => { id: search.slug, display: 'true' } } } }
-      SirTrevorRails::Blocks::SearchResultsBlock.new(content, home_page)
-    end
-
-    let(:bad) do
-      content = { type: 'xyz', data: { 'item' => { 'garbage' => { id: 'missing', display: 'true' } } } }
-      SirTrevorRails::Blocks::SearchResultsBlock.new(content, home_page)
-    end
-
-    let(:search_result) { [double('response'), double('documents')] }
-
-    it 'returns the results for a given search browse category' do
-      expect(helper).to receive(:search_results).with({ 'q' => 'query' }).and_return(search_result)
-      expect(helper.get_search_widget_search_results(good)).to eq search_result
-    end
-
-    it "returns an empty array when requesting a search that doesn't exist" do
-      expect(helper.get_search_widget_search_results(bad)).to be_empty
-    end
-  end
-
-  describe 'nestable helpers' do
-    describe 'nestable data attributes' do
-      it 'returns the appropriate attributes for feature pages' do
-        expect(helper.nestable_data_attributes('feature_pages')).to eq "data-max-depth='2' data-expand-btn-HTML='' data-collapse-btn-HTML=''"
-      end
-
-      it 'returns the appropriate attributes for about pages' do
-        expect(helper.nestable_data_attributes('about_pages')).to eq "data-max-depth='1'"
-      end
-
-      it 'returns a blank string if the type is not valid' do
-        expect(helper.nestable_data_attributes('something_else')).to eq ''
-      end
-    end
-
-    describe 'nestable data attributes hash' do
-      it 'returns the appropriate hash for feature pages' do
-        expect(helper.nestable_data_attributes_hash('feature_pages')).to eq('data-max-depth' => '2',
-                                                                            'data-expand-btn-HTML' => '',
-                                                                            'data-collapse-btn-HTML' => '')
-      end
-
-      it 'returns the appropriate hash for about pages' do
-        expect(helper.nestable_data_attributes_hash('about_pages')).to eq 'data-max-depth' => '1'
-      end
-
-      it 'returns an empty hash if the type is not valid' do
-        expect(helper.nestable_data_attributes_hash('something_else')).to eq({})
-      end
-    end
-  end
-
-  describe '#sir_trevor_markdown' 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 '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 '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
-    end
-  end
-
-  describe '#render_contact_email_address' do
-    it 'adds soft breaks in appropriate places' do
-      expect(helper.render_contact_email_address('local.part@example.com')).to have_css 'wbr', count: 3, visible: false
-    end
-  end
-end

data/spec/helpers/spotlight/roles_helper_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::RolesHelper, type: :helper do
-  it 'is a list of options' do
-    expect(helper.roles_for_select).to eq('Admin' => 'admin', 'Curator' => 'curator', 'Viewer' => 'viewer')
-  end
-end

data/spec/helpers/spotlight/search_configurations_helper_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::SearchConfigurationsHelper, type: :helper do
-  describe '#translate_sort_fields' do
-    let(:sort_config) do
-      Blacklight::OpenStructWithHashAccess.new(sort: 'score asc, sort_title_ssi desc')
-    end
-
-    it 'translates sort fields' do
-      expect(translate_sort_fields(sort_config)).to eq 'relevancy score ascending and title descending'
-    end
-
-    it 'humanizes untranslatable sort fields' do
-      sort_config.sort = 'some_other_field desc'
-      expect(translate_sort_fields(sort_config)).to eq 'some other field descending'
-    end
-
-    it 'supports explicit sort descriptions' do
-      sort_config.sort_description = 'xyz'
-      expect(translate_sort_fields(sort_config)).to eq 'xyz'
-    end
-  end
-end

data/spec/helpers/spotlight/title_helper_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::TitleHelper, type: :helper do
-  before do
-    allow(helper).to receive_messages(application_name: 'Application')
-  end
-
-  describe '#page_title' do
-    it 'sets the @page_title ivar' do
-      helper.page_title('Section', 'Title')
-      title = helper.instance_variable_get(:@page_title)
-      expect(title).to eq 'Section - Title | Application'
-    end
-
-    it 'renders the section title and the page title' do
-      title = helper.page_title('Section', 'Title')
-      expect(title).to have_selector 'h1', text: 'Section'
-      expect(title).to have_selector 'h1 small', text: 'Title'
-    end
-
-    it 'renders just the section title if that was all that was provided' do
-      allow(helper).to receive(:t).and_call_original
-      allow(helper).to receive(:t).with(:'.header', default: '').and_return('')
-
-      title = helper.page_title('Section')
-
-      expect(title).to have_selector 'h1', text: 'Section'
-      expect(title).not_to have_selector 'h1 small'
-
-      title = helper.instance_variable_get(:@page_title)
-      expect(title).to eq 'Section | Application'
-    end
-  end
-
-  describe '#set_html_page_title' do
-    it 'assigns the @page_title ivar' do
-      allow(helper).to receive_messages(application_name: 'B')
-      helper.set_html_page_title 'A'
-      title = helper.instance_variable_get(:@page_title)
-      expect(title).to eq 'A | B'
-    end
-
-    it 'strips out any HTML tags' do
-      allow(helper).to receive_messages(application_name: 'B')
-      expect(helper.set_html_page_title('<b>text</b> should not include HTML')).to eq 'text should not include HTML | B'
-    end
-  end
-
-  describe '#curation_page_title' do
-    it 'renders a page title in the curation section' do
-      title = helper.curation_page_title 'Some title'
-      expect(title).to have_selector 'h1', text: 'Curation'
-      expect(title).to have_selector 'h1 small', text: 'Some title'
-    end
-  end
-
-  describe '#configuration_page_title' do
-    it 'renders a page title in the configuration section' do
-      title = helper.configuration_page_title 'Some title'
-      expect(title).to have_selector 'h1', text: 'Configuration'
-      expect(title).to have_selector 'h1 small', text: 'Some title'
-    end
-  end
-end

data/spec/helpers/spotlight/translations_helper_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Spotlight::TranslationsHelper do
-  describe '#non_custom_metadata_fields' do
-    let(:exhibit) { FactoryBot.create(:exhibit) }
-    let!(:custom_field) { FactoryBot.create(:custom_field, exhibit: exhibit) }
-
-    before { allow(helper).to receive(:current_exhibit).and_return(exhibit) }
-
-    it "is an array of the current exhibit's metadata fields with the custom fields removed" do
-      expect(exhibit.blacklight_config.show_fields.keys).to include custom_field.field
-
-      expect(helper.non_custom_metadata_fields.keys).not_to include custom_field.field
-    end
-  end
-end

data/spec/i18n_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n/tasks'
-
-RSpec.describe 'I18n' do
-  let(:i18n) { I18n::Tasks::BaseTask.new }
-  let(:missing_keys) { i18n.missing_keys }
-  let(:unused_keys) { i18n.unused_keys }
-
-  xit 'does not have missing keys' do
-    expect(missing_keys).to be_empty,
-                            "Missing #{missing_keys.leaves.count} i18n keys, run `i18n-tasks missing' to show them"
-  end
-
-  xit 'does not have unused keys' do
-    expect(unused_keys).to be_empty,
-                           "#{unused_keys.leaves.count} unused i18n keys, run `i18n-tasks unused' to show them"
-  end
-
-  it 'files are normalized' do
-    non_normalized = i18n.non_normalized_paths
-    error_message = "The following files need to be normalized:\n" \
-                    "#{non_normalized.map { |path| "  #{path}" }.join("\n")}\n" \
-                    'Please run `i18n-tasks normalize` to fix'
-    expect(non_normalized).to be_empty, error_message
-  end
-end

data/spec/jobs/spotlight/add_tags_job_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::AddTagsJob do
-  subject { described_class.new(solr_params: solr_params, exhibit: exhibit, tags: tags) }
-
-  let(:solr_params) { { q: 'map' } }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:tags) { 'hello,world' }
-
-  before do
-    allow(Spotlight::Engine.config).to receive_messages(bulk_actions_batch_size: 5)
-  end
-
-  it 'adds tags to SolrDocumentSidecar objects' do
-    subject.perform_now
-    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
-    expect(response.total).to eq 55
-    expect(Spotlight::JobTracker.last).to have_attributes(
-      status: 'completed',
-      total: 55,
-      progress: 55,
-      job_class: 'Spotlight::AddTagsJob'
-    )
-    response.documents.each do |document|
-      expect(document.sidecar(exhibit).all_tags_list).to include('hello', 'world')
-      exhibit.tag(document.sidecar(exhibit), with: [], on: :tags)
-    end
-    exhibit.owned_tags.destroy_all
-    response.documents.each do |document|
-      document.sidecar(exhibit).destroy
-      document.reindex
-    end
-  end
-end

data/spec/jobs/spotlight/add_uploads_from_csv_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::AddUploadsFromCsv do
-  subject(:job) { described_class.new(data, exhibit, user) }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:user) { FactoryBot.create(:exhibit_curator, exhibit: exhibit) }
-  let(:data) do
-    [
-      { 'url' => 'x' },
-      { 'url' => 'y' },
-      { 'url' => '~' }
-    ]
-  end
-
-  let(:resource_x) { instance_double(Spotlight::Resource) }
-  let(:resource_y) { instance_double(Spotlight::Resource) }
-
-  before do
-    allow(Spotlight::IndexingCompleteMailer).to receive(:documents_indexed).and_return(double(deliver_now: true))
-  end
-
-  context 'with empty data' do
-    let(:data) { [] }
-
-    it 'sends the user an email after the indexing job is complete' do
-      expect(Spotlight::IndexingCompleteMailer).to receive(:documents_indexed).and_return(double(deliver_now: true))
-      job.perform_now
-    end
-  end
-
-  it 'creates uploaded resources for each row of data' do
-    upload = FactoryBot.create(:uploaded_resource)
-    expect(Spotlight::Resources::Upload).to receive(:new).exactly(3).times.and_return(upload)
-
-    expect(upload).to receive(:build_upload).with(remote_image_url: 'x').and_call_original
-    expect(upload).to receive(:build_upload).with(remote_image_url: 'y').and_call_original
-    expect(upload).not_to receive(:build_upload).with(remote_image_url: '~')
-    expect(upload).to receive(:save_and_index).at_least(:once)
-
-    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(Regexp.union(/relative URI: x/, /URI scheme '' not in whitelist:/))),
-          2 => array_including(match(/Upload is invalid/))
-        }
-      )
-    end
-  end
-end

data/spec/jobs/spotlight/change_visibility_job_spec.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::ChangeVisibilityJob do
-  subject { described_class.new(solr_params: solr_params, exhibit: exhibit, visibility: visibility) }
-
-  let(:solr_params) { { q: 'map' } }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:visibility) { 'private' }
-
-  before do
-    allow(Spotlight::Engine.config).to receive_messages(bulk_actions_batch_size: 5)
-  end
-
-  it 'sets the items based off of the visibility' do
-    subject.perform_now
-    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
-    expect(response.total).to eq 55
-    expect(Spotlight::JobTracker.last).to have_attributes(
-      status: 'completed',
-      total: 55,
-      progress: 55,
-      job_class: 'Spotlight::ChangeVisibilityJob'
-    )
-    response.documents.each do |document|
-      expect(document.private?(exhibit)).to be true
-      document.make_public!(exhibit)
-      document.reindex
-    end
-  end
-end

data/spec/jobs/spotlight/default_thumbnail_job_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::DefaultThumbnailJob do
-  subject { described_class.new(thumbnailable) }
-
-  let(:thumbnailable) { double('Thumbnailable') }
-
-  it 'calls #set_default_thumbnail on the object passed in and saves' do
-    expect(thumbnailable).to receive(:set_default_thumbnail)
-    expect(thumbnailable).to receive(:save)
-
-    subject.perform_now
-  end
-end

data/spec/jobs/spotlight/process_bulk_updates_csv_job_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-def tag_names(exhibit, id)
-  exhibit.blacklight_config.repository.find(id).documents.first.sidecar(exhibit).taggings.includes(:tag).map { |tagging| tagging&.tag&.name }
-end
-
-describe Spotlight::ProcessBulkUpdatesCsvJob do
-  subject { described_class.new(exhibit, bulk_update) }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  describe 'visibility' do
-    let(:bulk_update) { FactoryBot.create(:bulk_update, exhibit: exhibit) }
-
-    it 'is updated' do
-      allow(SolrDocument.index.connection).to receive(:update).and_call_original
-      expect(exhibit.blacklight_config.repository.find('dq287tq6352').documents.first).not_to be_private(exhibit)
-
-      subject.perform_now
-
-      expect(exhibit.blacklight_config.repository.find('dq287tq6352').documents.first).to be_private(exhibit)
-      expect(SolrDocument.index.connection).to have_received(:update)
-    end
-
-    context 'with a row that does not change visibility' do
-      before do
-        sidecar = exhibit.solr_document_sidecars.find_or_create_by(document_type: 'SolrDocument', document_id: 'dq287tq6352')
-        sidecar.private!
-      end
-
-      it 'does not update solr' do
-        allow(SolrDocument.index.connection).to receive(:update)
-
-        subject.perform_now
-
-        expect(SolrDocument.index.connection).not_to have_received(:update)
-      end
-    end
-
-    context 'without a visibility column' do
-      let(:bulk_update) { FactoryBot.create(:bulk_update_no_cols, exhibit: exhibit) }
-
-      it 'does nothing with the data' do
-        expect { subject.perform_now }.not_to(change { exhibit.reload.solr_document_sidecars.where(public: false).count })
-      end
-    end
-  end
-
-  describe 'tags' do
-    let(:bulk_update) { FactoryBot.create(:tagged_bulk_update, exhibit: exhibit) }
-
-    before do
-      document = exhibit.blacklight_config.repository.find('cz507zk0531').documents.first
-      exhibit.tag(document.sidecar(exhibit), with: 'CSV Tag1', on: :tags)
-    end
-
-    it 'are added/removed' do
-      allow(SolrDocument.index.connection).to receive(:update).and_call_original
-      expect(tag_names(exhibit, 'bm387cy2596')).to be_empty
-      expect(tag_names(exhibit, 'cz507zk0531')).to eq(['CSV Tag1'])
-      expect(tag_names(exhibit, 'dq287tq6352')).to be_empty
-      subject.perform_now
-      expect(tag_names(exhibit, 'bm387cy2596')).to eq(['CSV Tag1', 'CSV Tag2'])
-      expect(tag_names(exhibit, 'cz507zk0531')).to eq(['CSV Tag2'])
-      expect(tag_names(exhibit, 'dq287tq6352')).to eq(['CSV Tag1', 'CSV Tag2'])
-
-      # 3 updates plus the final commit
-      expect(SolrDocument.index.connection).to have_received(:update).exactly(4).times
-    end
-
-    context 'with a row that does not change visibility' do
-      before do
-        # set up the documents to match what's the in the spreadsheet already
-        subject.perform_now
-      end
-
-      it 'does not update solr' do
-        allow(SolrDocument.index.connection).to receive(:update)
-
-        subject.perform_now
-
-        expect(SolrDocument.index.connection).not_to have_received(:update)
-      end
-    end
-  end
-end

data/spec/jobs/spotlight/reindex_exhibit_job_spec.rb

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::ReindexJob do
-  include ActiveJob::TestHelper
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:resource) { FactoryBot.create(:resource, exhibit: exhibit) }
-  let(:user) { FactoryBot.create(:user) }
-
-  before do
-    allow_any_instance_of(Spotlight::Resource).to receive(:reindex)
-  end
-
-  context 'with a resource' do
-    subject { described_class.new(resource) }
-
-    it 'attempts to reindex every resource in the exhibit' do
-      expect(resource).to receive(:reindex)
-      subject.perform_now
-    end
-
-    it 'adds some job tracking events' do
-      expect { subject.perform_now }.to change(Spotlight::Event, :count).by(1)
-    end
-  end
-
-  describe 'validity' do
-    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(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, 'validity_token' => 'xyz')
-    end
-
-    it 'does nothing if the token is no longer valid' do
-      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(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/jobs/spotlight/remove_tags_job_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::RemoveTagsJob do
-  subject { described_class.new(solr_params: solr_params, exhibit: exhibit, tags: tags) }
-
-  let(:solr_params) { { q: 'map' } }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:tags) { %w[hello world] }
-
-  before do
-    allow(Spotlight::Engine.config).to receive_messages(bulk_actions_batch_size: 5)
-  end
-
-  it 'removes tags from SolrDocumentSidecar objects' do
-    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
-    expect(response.total).to eq 55
-    response.documents.each do |document|
-      exhibit.tag(document.sidecar(exhibit), with: %w[hello world], on: :tags)
-      document.reindex
-    end
-    subject.perform_now
-    response = exhibit.blacklight_config.repository.search(solr_params.merge('rows' => 999_999_999))
-    expect(response.total).to eq 55
-    expect(Spotlight::JobTracker.last).to have_attributes(
-      status: 'completed',
-      total: 55,
-      progress: 55,
-      job_class: 'Spotlight::RemoveTagsJob'
-    )
-    response.documents.each do |document|
-      expect(document.sidecar(exhibit).all_tags_list).to eq []
-    end
-    exhibit.owned_tags.destroy_all
-    response.documents.each do |document|
-      document.sidecar(exhibit).destroy
-      document.reindex
-    end
-  end
-end