blacklight-spotlight 3.4.0 → 3.4.1

data/spec/models/solr_document_spec.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-  its(:to_key) { is_expected.to eq ['abcd123'] }
-  its(:persisted?) { is_expected.to be_truthy }
-
-  describe '.build_for_exhibit' do
-    subject { described_class.build_for_exhibit(id, exhibit) }
-
-    let(:id) { '123abc' }
-
-    it 'has a persisted sidecar' do
-      expect(subject.sidecars.first).to be_persisted
-      expect(subject.sidecars.first.exhibit).to eq exhibit
-    end
-  end
-
-  it 'has tags on the exhibit' do
-    expect(subject.sidecar(exhibit).tags_from(exhibit)).to be_empty
-  end
-
-  it 'is able to add tags' do
-    expect do
-      exhibit.tag(subject.sidecar(exhibit), with: 'paris, normandy', on: :tags)
-    end.to change(ActsAsTaggableOn::Tag, :count).by(2)
-    expect(subject.sidecar(exhibit).tags_from(exhibit)).to eq %w[paris normandy]
-  end
-
-  it 'has find' do
-    expect(described_class.find('dq287tq6352')).to be_kind_of described_class
-  end
-
-  it 'has ==' do
-    expect(described_class.find('dq287tq6352')).to eq described_class.find('dq287tq6352')
-  end
-
-  describe 'GlobalID' do
-    let(:doc_id) { 'dq287tq6352' }
-
-    it 'responds to #to_global_id' do
-      expect(described_class.find(doc_id).to_global_id.to_s).to eq "gid://internal/SolrDocument/#{doc_id}"
-    end
-
-    it 'is able to locate SolrDocuments by their GlobalID' do
-      expect(GlobalID::Locator.locate(
-        described_class.find(doc_id).to_global_id
-      )['id']).to eq doc_id
-    end
-  end
-
-  describe '#sidecar' do
-    it 'returns a sidecar for adding exhibit-specific fields' do
-      expect(subject.sidecar(exhibit)).to be_kind_of Spotlight::SolrDocumentSidecar
-      expect(subject.sidecar(exhibit).exhibit).to eq exhibit
-    end
-
-    it 'keeps distinct sidecars for each exhibit' do
-      expect(subject.sidecar(exhibit).exhibit).to eq exhibit
-      expect(subject.sidecar(exhibit_alt).exhibit).to eq exhibit_alt
-    end
-  end
-
-  describe '#update' do
-    it 'stores sidecar data on the sidecar object' do
-      mock_sidecar = double
-      allow(subject).to receive_messages(sidecar: mock_sidecar)
-      expect(mock_sidecar).to receive(:update).with({ data: { 'a' => 1 } })
-      subject.update exhibit, sidecar: { data: { 'a' => 1 } }
-    end
-
-    it 'stores tags' do
-      subject.update exhibit, exhibit_tag_list: 'paris, normandy'
-      expect(subject.sidecar(exhibit).tags_from(exhibit)).to eq %w[paris normandy]
-    end
-
-    it 'converts empty strings to nil' do
-      mock_sidecar = double
-      allow(subject).to receive_messages(sidecar: mock_sidecar)
-      expect(mock_sidecar).to receive(:update).with({ data: { 'a' => nil } })
-      subject.update exhibit, sidecar: { data: { 'a' => '' } }
-    end
-
-    it 'compacts arrays of empty or nil values' do
-      mock_sidecar = double
-      allow(subject).to receive_messages(sidecar: mock_sidecar)
-      expect(mock_sidecar).to receive(:update).with({ data: { 'a' => ['a'] } })
-      subject.update exhibit, sidecar: { data: { 'a' => ['', nil, 'a'] } }
-    end
-  end
-
-  describe '#to_solr' do
-    before do
-      Spotlight::SolrDocumentSidecar.create! document: subject, exhibit: exhibit,
-                                             data: { 'a_tesim' => 1, 'b_tesim' => 2, 'c_tesim' => 3 }
-    end
-
-    it 'includes the doc id' do
-      expect(subject.to_solr[:id]).to eq 'abcd123'
-    end
-
-    it 'includes exhibit-specific tags' do
-      exhibit.tag(subject.sidecar(exhibit), with: 'paris', on: :tags)
-
-      expect(subject.to_solr).to include :"exhibit_#{exhibit.slug}_tags_ssim"
-      expect(subject.to_solr[:"exhibit_#{exhibit.slug}_tags_ssim"]).to include 'paris'
-    end
-
-    it "includes placeholders for all exhibits' tags" do
-      expect(subject.to_solr).to include :"exhibit_#{exhibit.slug}_tags_ssim"
-      expect(subject.to_solr[:"exhibit_#{exhibit.slug}_tags_ssim"]).to eq nil
-    end
-
-    it 'includes sidecar fields' do
-      expect(subject.to_solr).to include('a_tesim' => 1, 'b_tesim' => 2, 'c_tesim' => 3)
-    end
-  end
-
-  describe '#public?' do
-    it 'defaults to public' do
-      expect(subject).to be_public exhibit
-    end
-  end
-
-  describe '#private?' do
-    it 'defaults to public' do
-      expect(subject).not_to be_private exhibit
-    end
-  end
-
-  describe '#make_public!' do
-    it 'sets the object to public' do
-      allow(subject).to receive(:reindex)
-      subject.make_public! exhibit
-      expect(subject).not_to be_private exhibit
-    end
-
-    it 'augments existing sidecar data' do
-      allow(subject).to receive(:reindex)
-
-      subject.update exhibit, sidecar: { data: { a: 1 } }
-      subject.make_public! exhibit
-      expect(subject.sidecar(exhibit).data[:a]).to eq 1
-    end
-  end
-
-  describe '#make_private!' do
-    it 'sets the object to private' do
-      allow(subject).to receive(:reindex)
-      subject.make_private! exhibit
-      expect(subject).to be_private exhibit
-    end
-  end
-
-  describe 'uploaded resources' do
-    let(:uploaded_resource) do
-      described_class.new(
-        spotlight_resource_type_ssim: 'spotlight/resources/uploads'
-      )
-    end
-
-    it 'does not include Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
-      expect(subject).not_to be_kind_of Spotlight::SolrDocument::UploadedResource
-    end
-
-    it 'includes Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
-      expect(uploaded_resource).to be_kind_of Spotlight::SolrDocument::UploadedResource
-    end
-
-    describe '#uploaded_resource?' do
-      it 'returns false if the correct fields are not present' do
-        expect(subject).not_to be_uploaded_resource
-      end
-
-      it 'returns true when the correct fields are present' do
-        expect(uploaded_resource).to be_uploaded_resource
-      end
-    end
-  end
-
-  describe '.find_each' do
-    it 'enumerates the documents in the exhibit' do
-      expect(described_class.find_each).to be_a Enumerable
-    end
-
-    it 'pages through the index' do
-      allow_any_instance_of(Blacklight::Solr::Repository).to receive(:search).with(hash_including(start: 0)).and_return(double(documents: [1, 2, 3]))
-      allow_any_instance_of(Blacklight::Solr::Repository).to receive(:search).with(hash_including(start: 3)).and_return(double(documents: [4, 5, 6]))
-      allow_any_instance_of(Blacklight::Solr::Repository).to receive(:search).with(hash_including(start: 6)).and_return(double(documents: []))
-
-      expect(described_class.find_each.to_a).to match_array [1, 2, 3, 4, 5, 6]
-    end
-  end
-
-  describe '.reindex_all' do
-    let(:doc) { described_class.new id: 1 }
-
-    it 'reindexes all solr documents' do
-      expect(described_class).to receive(:find_each).and_yield(doc)
-      expect(doc).to receive(:reindex)
-
-      described_class.reindex_all
-    end
-  end
-end

data/spec/models/spotlight/ability_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-require 'cancan/matchers'
-
-describe Spotlight::Ability, type: :model do
-  subject { Ability.new(user) }
-
-  before do
-    allow_any_instance_of(Spotlight::Search).to receive(:set_default_featured_image)
-  end
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:search) { FactoryBot.create(:published_search, exhibit: exhibit) }
-  let(:unpublished_search) { FactoryBot.create(:search, exhibit: exhibit) }
-  let(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
-  let(:language) { FactoryBot.create(:language, exhibit: exhibit) }
-  let(:public_language) { FactoryBot.create(:language, exhibit: exhibit, public: true) }
-  let(:translation) { FactoryBot.create(:translation, exhibit: exhibit) }
-
-  describe 'a user with no roles' do
-    let(:user) { nil }
-
-    it { is_expected.not_to be_able_to(:create, exhibit) }
-    it { is_expected.to be_able_to(:read, exhibit) }
-    it { is_expected.to be_able_to(:read, page) }
-    it { is_expected.not_to be_able_to(:create, Spotlight::Page.new(exhibit: exhibit)) }
-    it { is_expected.to be_able_to(:read, search) }
-    it { is_expected.to be_able_to(:read, public_language) }
-    it { is_expected.not_to be_able_to(:read, language) }
-    it { is_expected.not_to be_able_to(:read, unpublished_search) }
-    it { is_expected.not_to be_able_to(:tag, exhibit) }
-  end
-
-  describe 'a superadmin' do
-    let(:user) { FactoryBot.create(:site_admin) }
-
-    it { is_expected.to be_able_to(:create, Spotlight::Exhibit) }
-  end
-
-  describe 'a user with admin role' do
-    let(:user) { FactoryBot.create(:exhibit_admin, exhibit: exhibit) }
-    let(:role) { FactoryBot.create(:role, resource: exhibit) }
-    let(:blacklight_config) { exhibit.blacklight_configuration }
-
-    it { is_expected.to be_able_to(:update, exhibit) }
-
-    it { is_expected.to be_able_to(:index, role) }
-    it { is_expected.to be_able_to(:destroy, role) }
-    it { is_expected.to be_able_to(:update, role) }
-    it { is_expected.to be_able_to(:create, Spotlight::Role) }
-    it { is_expected.not_to be_able_to(:create, Spotlight::Exhibit) }
-    it { is_expected.to be_able_to(:import, exhibit) }
-    it { is_expected.to be_able_to(:process_import, exhibit) }
-    it { is_expected.to be_able_to(:destroy, exhibit) }
-    it { is_expected.to be_able_to(:manage, language) }
-  end
-
-  describe 'a user with curate role' do
-    let(:user) { FactoryBot.create(:exhibit_curator, exhibit: exhibit) }
-    let(:contact) { FactoryBot.build_stubbed(:contact, exhibit: exhibit) }
-    let(:blacklight_config) { exhibit.blacklight_configuration }
-
-    it { is_expected.not_to be_able_to(:update, exhibit) }
-    it { is_expected.to be_able_to(:curate, exhibit) }
-    it { is_expected.to be_able_to(:read, exhibit) }
-
-    it { is_expected.to be_able_to(:create, Spotlight::Search) }
-    it { is_expected.to be_able_to(:update_all, Spotlight::Search) }
-    it { is_expected.to be_able_to(:update, search) }
-    it { is_expected.to be_able_to(:destroy, search) }
-
-    it { is_expected.to be_able_to(:create, Spotlight::Page) }
-    it { is_expected.to be_able_to(:update_all, Spotlight::Page) }
-    it { is_expected.to be_able_to(:update, page) }
-    it { is_expected.to be_able_to(:destroy, page) }
-
-    it { is_expected.to be_able_to(:create, Translation) }
-    it { is_expected.to be_able_to(:update_all, Translation) }
-    it { is_expected.to be_able_to(:update, translation) }
-    it { is_expected.to be_able_to(:destroy, translation) }
-
-    it { is_expected.to be_able_to(:tag, exhibit) }
-    it { is_expected.to be_able_to(:bulk_update, exhibit) }
-
-    it { is_expected.to be_able_to(:edit, contact) }
-    it { is_expected.to be_able_to(:new, contact) }
-    it { is_expected.to be_able_to(:create, contact) }
-    it { is_expected.to be_able_to(:destroy, contact) }
-    it { is_expected.not_to be_able_to(:manage, language) }
-    it { is_expected.to be_able_to(:read, language) }
-  end
-
-  context 'with an unpublished exhibit' do
-    before do
-      exhibit.update(published: false)
-    end
-
-    context 'with a user with a viewer role' do
-      let(:user) { FactoryBot.create(:user, :with_exhibit_role, role: 'viewer', exhibit: exhibit) }
-
-      it { is_expected.not_to be_able_to(:create, exhibit) }
-      it { is_expected.to be_able_to(:read, exhibit) }
-      it { is_expected.to be_able_to(:read, page) }
-      it { is_expected.not_to be_able_to(:create, Spotlight::Page.new(exhibit: exhibit)) }
-      it { is_expected.to be_able_to(:read, search) }
-      it { is_expected.to be_able_to(:read, public_language) }
-      it { is_expected.not_to be_able_to(:read, language) }
-      it { is_expected.not_to be_able_to(:read, unpublished_search) }
-      it { is_expected.not_to be_able_to(:tag, exhibit) }
-    end
-
-    context 'with an anonymous user' do
-      let(:user) { FactoryBot.create(:exhibit_visitor) }
-
-      it { is_expected.not_to be_able_to(:read, exhibit) }
-    end
-  end
-end

data/spec/models/spotlight/about_page_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::AboutPage, type: :model do
-  let(:page) { described_class.create! exhibit: FactoryBot.create(:exhibit) }
-
-  it { is_expected.not_to be_feature_page }
-  it { is_expected.to be_about_page }
-
-  it 'displays the sidebar' do
-    expect(page).to be_display_sidebar
-  end
-
-  it 'forces the sidebar to display (we do not provide an interface for setting this to false)' do
-    expect(page).to be_display_sidebar
-    page.display_sidebar = false
-    page.save
-    expect(page).to be_display_sidebar
-  end
-end

data/spec/models/spotlight/access_controls_enforcement_search_builder_spec.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::AccessControlsEnforcementSearchBuilder do
-  class MockSearchBuilder < Blacklight::SearchBuilder
-    attr_reader :blacklight_params, :scope
-
-    def initialize(blacklight_params, scope)
-      @blacklight_params = blacklight_params
-      @scope = scope
-    end
-    include Spotlight::AccessControlsEnforcementSearchBuilder
-    include Blacklight::Solr::SearchBuilderBehavior
-
-    def blacklight_config
-      scope.current_exhibit.blacklight_config
-    end
-  end
-
-  subject { MockSearchBuilder.new blacklight_params, scope }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:scope) { double(current_exhibit: exhibit, context: { current_ability: current_ability }) }
-  let(:current_ability) { instance_double(Ability) }
-  let(:solr_request) { Blacklight::Solr::Request.new }
-  let(:blacklight_params) { {} }
-
-  describe '#apply_permissive_visibility_filter' do
-    it 'allows curators to view everything' do
-      allow(current_ability).to receive(:can?).and_return(true)
-      subject.apply_permissive_visibility_filter(solr_request)
-      expect(solr_request.to_hash).to be_empty
-    end
-
-    it 'restricts searches to public items' do
-      allow(current_ability).to receive(:can?).and_return(false)
-
-      subject.apply_permissive_visibility_filter(solr_request)
-      expect(solr_request).to include :fq
-      expect(solr_request[:fq]).to include "-exhibit_#{exhibit.slug}_public_bsi:false"
-    end
-
-    it 'does not filter resources to just those created by the exhibit' do
-      allow(current_ability).to receive(:can?).and_return(true)
-      subject.apply_permissive_visibility_filter(solr_request)
-      expect(solr_request[:fq]).to be_blank
-    end
-  end
-
-  describe '#apply_exhibit_resources_filter' do
-    context 'with filter_resources_by_exhibit' do
-      before do
-        allow(Spotlight::Engine.config).to receive(:filter_resources_by_exhibit).and_return(true)
-      end
-
-      it 'filters resources to just those created by the exhibit' do
-        allow(current_ability).to receive(:can?).and_return(true)
-
-        subject.apply_exhibit_resources_filter(solr_request)
-
-        expect(solr_request).to include :fq
-        expect(solr_request[:fq]).to include "{!term f=spotlight_exhibit_slug_#{exhibit.slug}_bsi}true"
-      end
-    end
-
-    context 'with a custom exhibit filter' do
-      let(:filter) { exhibit.filters.first_or_initialize }
-
-      before do
-        filter.update(field: 'author_ssim', value: 'Coyne, Justin')
-      end
-
-      it 'filters resources to just those identified by the exhibit filter' do
-        allow(current_ability).to receive(:can?).and_return(true)
-
-        subject.apply_exhibit_resources_filter(solr_request)
-
-        expect(solr_request).to include :fq
-        expect(solr_request[:fq]).to include '{!term f=author_ssim}Coyne, Justin'
-      end
-    end
-  end
-end

data/spec/models/spotlight/analytics/ga_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::Analytics::Ga do
-  it 'does not be enabled without configuration' do
-    expect(subject).not_to be_enabled
-  end
-
-  describe '#site' do
-    it 'selects the correct profile based on the web property id' do
-      allow(Spotlight::Engine.config).to receive_messages(ga_web_property_id: 'bar')
-      allow(subject).to receive_message_chain(
-        :user,
-        :accounts,
-        :first,
-        profiles: [
-          double('profile1', web_property_id: 'foo'), double('profile2', web_property_id: 'bar')
-        ]
-      )
-      expect(subject.site.web_property_id).to eq 'bar'
-    end
-  end
-end

data/spec/models/spotlight/background_job_progress_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::BackgroundJobProgress, type: :model do
-  subject(:progress) { described_class.new(exhibit, job_class: Spotlight::ReindexExhibitJob) }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let!(:job_tracker) do
-    FactoryBot.create(
-      :job_tracker,
-      resource: exhibit,
-      on: exhibit,
-      job_class: 'Spotlight::ReindexExhibitJob',
-      updated_at: Time.zone.now,
-      **job_tracker_args
-    )
-  end
-  let(:job_tracker_args) { {} }
-
-  context 'with a completed job' do
-    let(:job_tracker_args) { { status: 'completed', data: { progress: 50, total: 50 } } }
-
-    it 'reports on reindexing progress' do
-      expect(progress.as_json).to include(
-        completed: 50,
-        total: 50,
-        finished: true,
-        errored: false,
-        recently_in_progress: true
-      )
-    end
-  end
-
-  context 'with a failed job' do
-    let(:job_tracker_args) { { status: 'failed', data: { progress: 32, total: 50 } } }
-
-    it 'reports on reindexing progress' do
-      expect(progress.as_json).to include(
-        completed: 32,
-        total: 50,
-        finished: true,
-        errored: true
-      )
-    end
-  end
-
-  context 'with an in-progress job' do
-    let(:job_tracker_args) { { status: 'in_progress', data: { progress: 32, total: 50 } } }
-
-    it 'reports on reindexing progress' do
-      expect(progress.as_json).to include(
-        completed: 32,
-        total: 50,
-        finished: false,
-        errored: false
-      )
-    end
-  end
-
-  context 'with an in-progress job with subtasks' do
-    before do
-      FactoryBot.create(:job_tracker, on: job_tracker, resource: exhibit, data: { progress: 32, total: 32 }, status: 'completed')
-      FactoryBot.create(:job_tracker, on: job_tracker, resource: exhibit, data: { progress: 16, total: 50 }, status: 'in_progress')
-    end
-
-    let(:job_tracker_args) { { status: 'in_progress' } }
-
-    it 'harvests total and completed data from the child jobs' do
-      expect(progress.as_json).to include(
-        completed: 48,
-        total: 82
-      )
-    end
-
-    it 'is not completed until all the child jobs are finished' do
-      job_tracker.update(status: 'failed')
-
-      expect(progress.as_json).to include(
-        finished: false,
-        errored: true
-      )
-    end
-  end
-
-  context 'with no job' do
-    before do
-      job_tracker.delete
-    end
-
-    it 'reports on reindexing progress' do
-      expect(progress.as_json).to include(
-        completed: 0,
-        total: 0,
-        finished: false,
-        errored: false,
-        recently_in_progress: false
-      )
-    end
-  end
-
-  context 'with multiple job trackers' do
-    let(:job_tracker_args) { { status: 'in_progress' } }
-
-    before do
-      FactoryBot.create(
-        :job_tracker,
-        resource: exhibit,
-        on: exhibit,
-        job_class: 'Spotlight::ReindexExhibitJob',
-        updated_at: Time.zone.now,
-        status: 'completed'
-      )
-    end
-
-    it 'uses the currently in-progress tracker' do
-      expect(progress.as_json).to include(finished: false)
-    end
-  end
-
-  context 'with multiple in-progress trackers' do
-    let(:job_tracker_args) { { status: 'in_progress' } }
-
-    before do
-      FactoryBot.create(
-        :job_tracker,
-        resource: exhibit,
-        on: exhibit,
-        job_class: 'Spotlight::ReindexExhibitJob',
-        updated_at: Time.zone.now - 5.years,
-        status: 'in_progress'
-      )
-    end
-
-    it 'uses the most recently updated tracker' do
-      expect(Time.zone.parse(progress.as_json[:updated_at]).year).to eq job_tracker.updated_at.year
-    end
-  end
-end