blacklight-spotlight 3.4.0 → 3.4.1

data/spec/models/spotlight/home_page_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::HomePage, type: :model do
-  let(:home_page) { FactoryBot.create(:home_page) }
-
-  it { is_expected.not_to be_feature_page }
-  it { is_expected.not_to be_about_page }
-
-  it 'displays the sidebar' do
-    expect(home_page).to be_display_sidebar
-  end
-
-  it 'is published' do
-    expect(home_page.published).to be_truthy
-  end
-
-  describe 'title' do
-    it 'includes default text' do
-      expect(home_page.title).to eq described_class.default_title_text
-    end
-  end
-
-  describe 'should_display_title?' do
-    it 'returns the display_title attribute' do
-      home_page.display_title = true
-      expect(home_page).to be_should_display_title
-      home_page.display_title = false
-      expect(home_page).not_to be_should_display_title
-    end
-  end
-
-  describe 'display_sidebar?' do
-    it 'is false when the page disabled the display_sidebar' do
-      home_page.display_sidebar = false
-      expect(home_page).not_to be_display_sidebar
-    end
-  end
-end

data/spec/models/spotlight/language_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Spotlight::Language do
-  describe '#to_native' do
-    it 'is the native translation of the locale' do
-      expect(described_class.new(locale: 'de').to_native).to eq 'Deutsch'
-    end
-
-    it 'is a blank string when the locale does not exist (for string comparison)' do
-      expect(described_class.new(locale: 'xx').to_native).to eq ''
-    end
-  end
-
-  describe 'when being destroyed' do
-    let(:exhibit) { FactoryBot.create(:exhibit) }
-    let(:language) { described_class.create(locale: 'es', exhibit: exhibit) }
-
-    before { Translation.current_exhibit = exhibit }
-
-    it 'also destroys its locale related pages' do
-      page_es = exhibit.home_page.clone_for_locale('es').tap(&:save)
-
-      expect(Spotlight::Page.exists?(page_es.id)).to be true
-
-      expect do
-        language.destroy
-      end.to change(Spotlight::Page, :count).by(-1)
-
-      expect(Spotlight::Page.exists?(page_es.id)).to be false
-    end
-
-    it 'also destroys its locale related translations' do
-      translation = FactoryBot.create(:translation, key: 'some.key', exhibit: exhibit, locale: 'es')
-
-      expect do
-        language.destroy
-      end.to change(Translation, :count).by(-1)
-
-      expect(Translation.exists?(translation.id)).to be false
-    end
-  end
-end

data/spec/models/spotlight/main_navigation_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::MainNavigation, type: :model do
-  before do
-    subject.exhibit = FactoryBot.create(:exhibit)
-  end
-
-  it 'has a default_label' do
-    subject.nav_type = :curated_features
-    expect(subject.default_label).to eq 'Curated features'
-  end
-
-  it 'returns the use the default label in the absence of a label' do
-    expect(subject.label).to be_blank
-    expect(subject.label_or_default).to eq subject.default_label
-    subject.label = 'something else'
-    expect(subject.label_or_default).to eq 'something else'
-  end
-end

data/spec/models/spotlight/masthead_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::Masthead, type: :model do
-  let(:masthead) { stub_model(described_class) }
-
-  describe '#iiif_url' do
-    it 'inlcudes the appropriate size' do
-      masthead.iiif_tilesource = 'http://example.com/iiif/abc123/info.json'
-      expect(masthead.iiif_url).to match(%r{/full/1800,180/})
-    end
-  end
-
-  describe '#display?' do
-    subject { masthead.display? }
-
-    let(:image) { OpenStruct.new }
-
-    context 'when the masthead is set to not display' do
-      it { is_expected.to be_falsey }
-    end
-
-    context 'when the cropped image is not present' do
-      before { masthead.display = true }
-
-      it { is_expected.to be_falsey }
-    end
-
-    context 'when the cropped image is present' do
-      before do
-        masthead.iiif_tilesource = 'http://test.host/images/1'
-        masthead.iiif_region = '100,0,200,300'
-      end
-
-      context 'but the masthead is set to not display' do
-        it { is_expected.to be_falsey }
-      end
-
-      context 'and the masthead is set to display' do
-        before { masthead.display = true }
-
-        it { is_expected.to be_truthy }
-      end
-    end
-  end
-end

data/spec/models/spotlight/page_configurations_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::PageConfigurations, type: :model do
-  subject(:page_config) { described_class.new(context: view_context, page: page) }
-
-  let(:view_context) do
-    double(
-      'ViewContext',
-      available_view_fields: [],
-      current_exhibit: exhibit,
-      blacklight_config: exhibit.blacklight_config,
-      document_show_link_field: 'document_show_link_field',
-      index_field_label: 'index_field_label',
-      index_fields: [],
-      spotlight: spotlight,
-      t: 'translated-content'
-    )
-  end
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
-
-  describe '#as_json' do
-    it 'is a json-able object (hash)' do
-      expect(page_config.as_json).to be_a Hash
-    end
-  end
-
-  describe 'downstream configured_params' do
-    it 'merges the supplied hash into the configs' do
-      expect(page_config).to receive_messages(configured_params: { hello: 'goodbye' })
-
-      expect(page_config.as_json).to include(hello: 'goodbye')
-    end
-
-    it 'sends the #call method to the value if it can respond (e.g. a lamda)' do
-      expect(view_context).to receive_messages(my_custom_plugin_path: 'my_custom_plugin/data.json')
-      expect(page_config).to receive_messages(
-        configured_params: { 'my-custom-plugin-path': ->(config) { config.context.my_custom_plugin_path } }
-      )
-
-      expect(page_config.as_json).to include('my-custom-plugin-path': 'my_custom_plugin/data.json')
-    end
-  end
-end

data/spec/models/spotlight/page_spec.rb

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::Page, type: :model do
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-  let!(:parent_page) { Spotlight::FeaturePage.create! exhibit: exhibit, published: true }
-  let!(:child_page) { Spotlight::FeaturePage.create! exhibit: exhibit, published: false, parent_page: parent_page }
-
-  describe '.at_top_level' do
-    it 'scopes results to only top level pages' do
-      expect(described_class.at_top_level).not_to include child_page
-    end
-  end
-
-  describe '.published' do
-    it 'scopes results to only published pages' do
-      expect(described_class.at_top_level).not_to include child_page
-    end
-  end
-
-  it 'is expected to be versioned' do
-    expect(subject).to be_versioned
-  end
-
-  describe '#top_level_page?' do
-    it 'checks if the page is a top-level page' do
-      expect(parent_page).to be_a_top_level_page
-      expect(child_page).not_to be_a_top_level_page
-    end
-  end
-
-  describe '#top_level_page_or_self' do
-    it 'fetches the top level page' do
-      expect(child_page.top_level_page_or_self).to be parent_page
-    end
-
-    it 'is the same object if the page is a top level page' do
-      expect(parent_page.top_level_page_or_self).to be parent_page
-    end
-  end
-
-  describe '.display_sidebar' do
-    it 'is set to true by default' do
-      expect(parent_page).to be_display_sidebar
-    end
-  end
-
-  describe 'should_display_title?' do
-    let(:page) { FactoryBot.create(:feature_page) }
-
-    it 'returns if the title is present or not' do
-      expect(page.title).not_to be_blank
-      expect(page).to be_should_display_title
-      page.title = ''
-      expect(page).not_to be_should_display_title
-    end
-  end
-
-  describe '#content=' do
-    let(:page) { FactoryBot.create(:feature_page) }
-
-    context 'with an alternate page content type' do
-      let(:page) { FactoryBot.create(:feature_page, content_type: 'Static') }
-      let(:fake_class) do
-        Class.new do
-          def self.parse(*_args)
-            'xyz'
-          end
-        end
-      end
-
-      before do
-        # needed so we don't accidentally stub Spotlight::PageContent below
-        require 'spotlight/page_content'
-        stub_const('Spotlight::PageContent::Static', fake_class)
-      end
-
-      it 'works' do
-        page.content = [].to_json
-        expect(page.content).to eq 'xyz'
-      end
-    end
-  end
-
-  describe '#content?' do
-    let(:page) { FactoryBot.create(:feature_page) }
-
-    it 'does not have content when the page is empty' do
-      page.content = []
-      expect(page).not_to have_content
-    end
-
-    it 'has content when the page has a widget' do
-      page.content = [{ type: 'rule' }]
-      expect(page).to have_content
-    end
-  end
-
-  describe '#content_type' do
-    let(:page) { FactoryBot.create(:feature_page) }
-
-    it 'can be set as an attribute' do
-      page.content_type = 'Xyz'
-      expect(page.content_type).to eq 'Xyz'
-    end
-
-    it 'defauts to SirTrevor' do
-      expect(page.content_type).to eq 'SirTrevor'
-    end
-  end
-
-  describe '#slug' do
-    let(:page) { FactoryBot.create(:about_page) }
-
-    it 'gets a default slug' do
-      expect(page.slug).not_to be_blank
-    end
-
-    it 'is updated when the title changes' do
-      page.update(title: 'abc')
-      expect(page.slug).to eq 'abc'
-    end
-
-    it 'reserves the slug "contacts"' do
-      page.update(title: 'contacts')
-      expect(page.slug).not_to eq 'contacts'
-    end
-
-    context 'with a custom slug' do
-      let(:page) { FactoryBot.create(:feature_page, slug: 'xyz') }
-
-      it 'gets a default slug' do
-        expect(page.slug).to eq 'xyz'
-      end
-    end
-  end
-
-  describe 'thumbnail_image_url' do
-    subject(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
-
-    let(:thumbnail) { FactoryBot.create(:featured_image) }
-
-    it 'is nil when there is no thumbnail' do
-      expect(page.thumbnail_image_url).to be_nil
-    end
-
-    it "is returns the thumbnail's IIIF url" do
-      page.thumbnail = thumbnail
-      expect(page.thumbnail_image_url).to eq thumbnail.iiif_url
-    end
-  end
-
-  describe 'updated_after?' do
-    let!(:old_page) { FactoryBot.create(:feature_page, updated_at: 10.seconds.ago) }
-    let!(:new_page) { FactoryBot.create(:feature_page) }
-
-    it 'compares the updated_at of the two objects' do
-      expect(new_page).to be_updated_after(old_page)
-    end
-  end
-
-  describe 'translated_pages' do
-    subject!(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
-
-    let!(:page_es) { FactoryBot.create(:feature_page, exhibit: exhibit, locale: 'es', default_locale_page: page) }
-
-    it 'is a relation of the other pages that indicate they belong to this page' do
-      expect(page.translated_pages.length).to eq 1
-      expect(page.translated_pages.first).to eq page_es
-    end
-  end
-
-  describe 'clone_for_locale' do
-    subject!(:cloned_page) { page.clone_for_locale('es') }
-
-    let(:page) { FactoryBot.create(:feature_page, exhibit: exhibit, published: true) }
-
-    it 'creates a new page' do
-      expect do
-        cloned_page.save
-      end.to change(described_class, :count).by(1)
-    end
-
-    it 'has the given locale' do
-      expect(cloned_page.locale).to eq 'es'
-    end
-
-    it 'sets the default_locale_page to self' do
-      expect(cloned_page.default_locale_page).to eq page
-    end
-
-    it 'does not copy the published attribute to the cloned page' do
-      expect(page).to be_published
-      expect(cloned_page).not_to be_published
-    end
-
-    context 'when cloning a child page' do
-      let(:parent_page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
-      let(:parent_cloned_page) { parent_page.clone_for_locale('es') }
-
-      before do
-        parent_cloned_page.save
-        page.update(parent_page_id: parent_page.id)
-      end
-
-      it 'associates the page with the translated version (if present)' do
-        expect(page.clone_for_locale('es').parent_page.id).to eq parent_cloned_page.id
-      end
-    end
-
-    context 'when cloning a page that has been deleted with a FriendlyId UUID added' do
-      let(:feature_page_static_title) { FactoryBot.create(:feature_page_static_title, exhibit: exhibit) }
-      let(:feature_page_static_title_two) { FactoryBot.create(:feature_page_static_title, exhibit: exhibit) }
-
-      it 'translated page has the same UUID' do
-        expect(feature_page_static_title.slug).to eq 'featurepage'
-        expect(feature_page_static_title_two.slug).not_to eq feature_page_static_title.slug
-        expect(feature_page_static_title_two.clone_for_locale('es').slug).to eq feature_page_static_title_two.slug
-      end
-    end
-
-    context 'when cloning a parent page whose children pages have already been cloned' do
-      let(:parent_page_es) { parent_page.clone_for_locale('es') }
-      let(:child_page_es) { child_page.clone_for_locale('es') }
-
-      before { child_page_es.save }
-
-      it 'updates the translated child pages with the correct parent association' do
-        expect(child_page_es.parent_page).to eq parent_page
-        parent_page_es.save
-        expect(child_page_es.reload.parent_page).to eq parent_page_es
-      end
-    end
-  end
-
-  describe 'syncing data between translated pages' do
-    let!(:parent_page_es) do
-      FactoryBot.create(
-        :feature_page,
-        exhibit: exhibit,
-        locale: 'es',
-        default_locale_page: parent_page
-      )
-    end
-    let!(:child_page_es) do
-      FactoryBot.create(
-        :feature_page,
-        exhibit: exhibit,
-        locale: 'es',
-        default_locale_page: child_page,
-        parent_page: parent_page_es
-      )
-    end
-    let!(:another_translated_page_es) do
-      FactoryBot.create(
-        :feature_page,
-        exhibit: exhibit,
-        locale: 'es',
-        default_locale_page: another_translated_page
-      )
-    end
-    let!(:another_page) { Spotlight::FeaturePage.create exhibit: exhibit, published: true }
-    let!(:another_translated_page) { Spotlight::FeaturePage.create exhibit: exhibit, published: true }
-
-    it 'updates the translated pages weight' do
-      expect(parent_page_es.weight).not_to be 5
-      parent_page.update(weight: 5)
-      expect(parent_page_es.reload.weight).to be 5
-    end
-
-    it 'sets the parent page id to the equivalent translated parent page' do
-      child_page.update(parent_page: another_translated_page)
-      expect(child_page_es.reload.parent_page).to eq another_translated_page_es
-    end
-
-    it 'updates the parent page when the default locale page becomes a top-level page' do
-      expect(child_page_es.parent_page).to eq parent_page_es
-      child_page.update(parent_page: nil)
-      expect(child_page_es.reload.parent_page).to be_nil
-    end
-
-    it 'removes the parent page id when the child page is set to an as-yet-untranslated parent page' do
-      child_page.update(parent_page: another_page)
-      expect(child_page_es.reload.parent_page).to be_nil
-    end
-
-    it 'updates the attributes separately' do
-      expect(child_page_es.parent_page).to eq parent_page_es
-      child_page.update(weight: 5)
-      expect(child_page_es.reload.weight).to eq 5
-      expect(child_page_es.reload.parent_page).to eq parent_page_es
-    end
-  end
-end

data/spec/models/spotlight/resource_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::Resource, type: :model do
-  subject(:resource) { described_class.create(id: 123, exhibit: exhibit) }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  describe '#save_and_index' do
-    before do
-      allow(subject).to receive(:save)
-      allow(subject).to receive(:reindex_later)
-    end
-
-    it 'saves the object' do
-      expect(subject).to receive(:save).and_return(true)
-      subject.save_and_index
-    end
-
-    it 'reindexes after save' do
-      expect(subject).to receive(:save).and_return(true)
-      expect(subject).to receive(:reindex_later)
-      subject.save_and_index
-    end
-
-    it 'passes through reindexing options' do
-      expect(subject).to receive(:save).and_return(true)
-      expect(subject).to receive(:reindex_later).with(a: 1)
-      subject.save_and_index(reindex_options: { a: 1 })
-    end
-
-    context 'if the save fails' do
-      it 'does not reindex' do
-        expect(subject).to receive(:save).and_return(false)
-        expect(subject).not_to receive(:reindex_later)
-        subject.save_and_index
-      end
-    end
-  end
-
-  describe '#reindex_later' do
-    around do |block|
-      old = ActiveJob::Base.queue_adapter
-      begin
-        ActiveJob::Base.queue_adapter = :test
-
-        block.call
-      ensure
-        ActiveJob::Base.queue_adapter = old
-      end
-    end
-
-    it 'passes through reindexing options' do
-      expect { subject.reindex_later(whatever: true) }.to have_enqueued_job(Spotlight::ReindexJob).with(subject, whatever: true, 'validity_token' => nil)
-    end
-  end
-
-  describe '#reindex' do
-    before do
-      # sneak some data into the pipeline
-      subject.indexing_pipeline.transforms = [->(*) { { id: '123' } }] + subject.indexing_pipeline.transforms
-    end
-
-    let(:indexed_document) do
-      result = nil
-
-      subject.reindex(**index_args) do |data, *|
-        result = data
-
-        # skip actually indexing the document into the solr index
-        throw :skip
-      end
-
-      result
-    end
-
-    let(:index_args) { {} }
-
-    it 'returns the number of items indexed' do
-      expect(subject.reindex { |*| throw :skip }).to eq 1
-    end
-
-    it 'applies exhibit-specific metadata from the sidecar' do
-      expect(indexed_document).to include Spotlight::SolrDocumentSidecar.new(document: SolrDocument.new(id: '123'), exhibit: exhibit).to_solr
-    end
-
-    it 'includes metata from each sidecar' do
-      a = Spotlight::SolrDocumentSidecar.create(document: SolrDocument.new(id: '123'), exhibit: exhibit)
-      b = Spotlight::SolrDocumentSidecar.create(document: SolrDocument.new(id: '123'), exhibit: FactoryBot.build(:exhibit))
-
-      expect(indexed_document).to include(a.to_solr).and(include(b.to_solr))
-    end
-
-    it 'persists a sidecar document' do
-      expect { indexed_document }.to change(Spotlight::SolrDocumentSidecar, :count).by(1)
-
-      expect(Spotlight::SolrDocumentSidecar.last).to have_attributes(document_id: '123', exhibit: exhibit)
-    end
-
-    it 'applies application metadata' do
-      expect(indexed_document).to include(spotlight_resource_id_ssim: resource.to_global_id.to_s, spotlight_resource_type_ssim: 'spotlight/resources')
-    end
-
-    context 'with some provided metadata' do
-      let(:index_args) { { additional_metadata: { a: 1 } } }
-
-      it 'applies externally provided metadata' do
-        expect(indexed_document).to include a: 1
-      end
-    end
-
-    it 'touches the exhibit to bust any caches' do
-      allow(exhibit).to receive(:touch)
-
-      indexed_document
-
-      expect(exhibit).to have_received(:touch)
-    end
-
-    context 'with touch: false' do
-      it 'does not touch the exhibit' do
-        allow(exhibit).to receive(:touch)
-
-        expect(subject.reindex(touch: false) { |*| throw :skip }).to eq 1
-
-        expect(exhibit).not_to have_received(:touch)
-      end
-    end
-  end
-
-  it 'stores arbitrary data' do
-    subject.data[:a] = 1
-    subject.data[:b] = 2
-
-    expect(subject.data[:a]).to eq 1
-    expect(subject.data[:b]).to eq 2
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spotlight::Resources::IiifHarvester do
-  subject(:harvester) { described_class.create(exhibit_id: exhibit.id, url: url) }
-
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  describe 'Validation' do
-    context 'when given an invalid URL' do
-      before do
-        stub_request(:head, 'http://example.com').to_return(status: 200, headers: { 'Content-Type' => 'text/html' })
-      end
-
-      let(:url) { 'http://example.com' }
-
-      it 'errors when the URL is not a IIIF URL' do
-        expect(subject).not_to be_valid
-        expect(subject.errors).to be_present
-        expect(subject.errors[:url]).to eq ['Invalid IIIF URL']
-      end
-    end
-
-    context 'when not responding to a HEAD request' do
-      before do
-        stub_request(:head, 'http://example.com').to_return(status: 405, headers: { 'Content-Type' => 'text/html' })
-        stub_request(:get, 'http://example.com').to_return(status: 200, headers: { 'Content-Type' => ' application/ld+json' })
-      end
-
-      let(:url) { 'http://example.com' }
-
-      it 'no errors when the URL responds to the GET request' do
-        expect(subject).to be_valid
-        expect(subject.errors).not_to be_present
-      end
-    end
-  end
-
-  describe '#reindex' do
-    let(:url) { 'uri://for-top-level-collection' }
-
-    before do
-      stub_default_collection
-      allow(Spotlight::Engine.config).to receive(:writable_index).and_return(false)
-    end
-
-    it 'indexes all the solr documents' do
-      expect(subject.reindex).to eq 8
-    end
-  end
-end