blacklight-spotlight 1.5.1 → 2.0.0.rc1

data/spec/features/javascript/locale_selector_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Locale Selector', js: true do
+  let(:exhibit) { FactoryBot.create(:exhibit, published: true) }
+  let!(:language_es) { FactoryBot.create(:language, exhibit: exhibit, locale: 'es', public: true) }
+  let!(:language_zh) { FactoryBot.create(:language, exhibit: exhibit, locale: 'zh') }
+
+  before { login_as user }
+
+  context 'with an anonymous user' do
+    let(:user) { FactoryBot.create(:exhibit_visitor) }
+
+    it 'only sees public languages' do
+      visit spotlight.exhibit_path(exhibit)
+
+      expect(page).to have_css('li.dropdown', text: 'English')
+      click_link 'English'
+
+      within('.dropdown-menu', visible: true) do
+        expect(page).to have_css('li', count: 1)
+        expect(page).to have_css('li', text: 'Español')
+      end
+    end
+  end
+
+  context 'with an exhibit curator' do
+    let(:user) { FactoryBot.create(:exhibit_curator, exhibit: exhibit) }
+
+    it 'can see any saved languages' do
+      visit spotlight.exhibit_path(exhibit)
+
+      expect(page).to have_css('li.dropdown', text: 'English')
+      click_link 'English'
+
+      within('.dropdown-menu', visible: true) do
+        expect(page).to have_css('li', count: 2)
+        expect(page).to have_css('li', text: '中文')
+        expect(page).to have_css('li', text: 'Español')
+      end
+    end
+  end
+
+  describe 'switching locales' do
+    let(:user) { FactoryBot.create(:exhibit_visitor) }
+
+    it 'works' do
+      visit spotlight.exhibit_path(exhibit)
+
+      expect(page).to have_css('input[placeholder="Search..."]')
+
+      click_link 'English'
+
+      within('.dropdown-menu', visible: true) do
+        click_link 'Español'
+      end
+
+      expect(page).not_to have_css('input[placeholder="Search..."]')
+      expect(page).to have_css('input[placeholder="Buscar..."]')
+    end
+  end
+end

data/spec/helpers/spotlight/languages_helper_spec.rb

@@ -0,0 +1,73 @@
+describe Spotlight::LanguagesHelper, type: :helper do
+  let(:current_exhibit) { FactoryBot.create(:exhibit) }
+  describe '#add_exhibit_language_dropdown_options' do
+    it 'returns a sorted Array of locales and their names' do
+      allow(helper).to receive_messages(current_exhibit: current_exhibit)
+      expect(helper.add_exhibit_language_dropdown_options).to match_array(
+        [
+          ['Albanian', :sq],
+          ['Chinese', :zh],
+          ['Dutch', :nl],
+          ['French', :fr],
+          ['German', :de],
+          ['Hungarian', :hu],
+          ['Italian', :it],
+          ['Portugese - Brazil', :'pt-br'],
+          ['Spanish', :es]
+        ]
+      )
+    end
+  end
+
+  describe '#locale_selecter_dropown_options' do
+    before do
+      allow(helper).to receive_messages(current_ability: Ability.new(nil))
+      allow(helper).to receive_messages(current_exhibit: current_exhibit)
+
+      current_exhibit.languages = [
+        FactoryBot.create(:language, public: true, locale: 'es'),
+        FactoryBot.create(:language, public: true, locale: 'de')
+      ]
+      current_exhibit.save
+    end
+
+    it 'includes the default locale (when it is not current)' do
+      allow(I18n).to receive(:locale).and_return(:es)
+      expect(helper.locale_selecter_dropown_options.last).to be_a(Spotlight::Language)
+      expect(helper.locale_selecter_dropown_options.last).not_to be_persisted
+      expect(helper.locale_selecter_dropown_options.last.locale).to eq 'en'
+    end
+
+    it 'does not include the current locale' do
+      expect(
+        helper.locale_selecter_dropown_options.map(&:locale)
+      ).not_to include(I18n.locale.to_s)
+    end
+
+    it 'sorts by the native translation' do
+      allow(I18n).to receive(:locale).and_return(:it)
+
+      expect(
+        helper.locale_selecter_dropown_options.map(&:to_native)
+      ).to eq %w[Deutsch English Español]
+    end
+  end
+
+  describe '#default_language?' do
+    context 'when using default locale' do
+      it do
+        expect(helper.default_language?).to eq true
+      end
+      it do
+        expect(helper).to receive_messages(params: { locale: :en })
+        expect(helper.default_language?).to eq true
+      end
+    end
+    context 'when using a different locale' do
+      it do
+        expect(helper).to receive_messages(params: { locale: :it })
+        expect(helper.default_language?).to eq false
+      end
+    end
+  end
+end

data/spec/helpers/spotlight/translations_helper_spec.rb

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'i18n/tasks'
+
+# rubocop:disable RSpec/DescribeClass
+RSpec.describe 'I18n' do
+  let(:i18n) { I18n::Tasks::BaseTask.new }
+  let(:missing_keys) { i18n.missing_keys }
+  let(:unused_keys) { i18n.unused_keys }
+
+  pending '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
+
+  it '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
+# rubocop:enable RSpec/DescribeClass

data/spec/lib/migration/page_language_spec.rb

@@ -0,0 +1,21 @@
+require 'migration/page_language'
+
+RSpec.describe Migration::PageLanguage do
+  describe '#migrate_pages' do
+    let(:exhibit) { FactoryBot.create(:exhibit) }
+    let(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
+    let(:slug) { FriendlyId::Slug.find(page.id) }
+    before do
+      # Remove the locale scope (anticipating pre translation state of scope)
+      slug.scope = slug.scope.sub(',locale:en', '')
+      slug.save
+      slug.reload
+    end
+    it 'sets the scope to the default locale' do
+      expect(slug.scope).not_to include(',locale:en')
+      subject.run
+      slug.reload
+      expect(slug.scope).to eq "exhibit_id:#{page.exhibit.id},locale:en"
+    end
+  end
+end

data/spec/lib/spotlight/upload_field_config_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Spotlight::UploadFieldConfig do
+  describe '#label' do
+    it 'accepts a proc and calls it' do
+      label = -> { 'returned string' }
+      expect(described_class.new(field_name: 'something', label: label).label).to eq 'returned string'
+    end
+
+    it 'returns any non-proc value' do
+      expect(described_class.new(field_name: 'something', label: 'String').label).to eq 'String'
+    end
+
+    it 'falls back to the field name when no label is given' do
+      expect(described_class.new(field_name: 'something').label).to eq 'something'
+    end
+  end
+
+  describe '#solr_field' do
+    it 'is an alias of the #solr_field method so it can be polymorphic with other Blacklight configurations' do
+      expect(described_class.new(field_name: 'something').solr_field).to eq 'something'
+    end
+  end
+end

data/spec/models/spotlight/ability_spec.rb

@@ -4,10 +4,13 @@ describe Spotlight::Ability, type: :model do
   before do
     allow_any_instance_of(Spotlight::Search).to receive(:set_default_featured_image)
   end
-  let(:exhibit) { FactoryBot.build_stubbed(:exhibit) }
-  let(:search) { FactoryBot.build_stubbed(:published_search, exhibit: exhibit) }
-  let(:unpublished_search) { FactoryBot.build_stubbed(:search, exhibit: exhibit) }
-  let(:page) { FactoryBot.build_stubbed(:feature_page, exhibit: exhibit) }
+  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) }
   subject { Ability.new(user) }
 
   describe 'a user with no roles' do
@@ -17,6 +20,8 @@ describe Spotlight::Ability, type: :model do
     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
@@ -42,6 +47,7 @@ describe Spotlight::Ability, type: :model do
     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
@@ -63,11 +69,18 @@ describe Spotlight::Ability, type: :model do
     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(: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
 end

data/spec/models/spotlight/exhibit_spec.rb

@@ -16,6 +16,24 @@ describe Spotlight::Exhibit, type: :model do
     subject.save!
     expect(subject.description).to eq 'Test description'
   end
+
+  describe 'validations' do
+    it 'validates the presence of the title' do
+      exhibit.title = ''
+      expect do
+        exhibit.save
+      end.to change { exhibit.errors[:title].count }.by(1)
+    end
+
+    it 'does not validate the presence of the title under a non-default locale' do
+      expect(I18n).to receive(:locale).and_return(:fr)
+      exhibit.title = ''
+      expect do
+        exhibit.save
+      end.not_to(change { exhibit.errors[:title].count })
+    end
+  end
+
   describe 'contact_emails' do
     before do
       subject.contact_emails_attributes = [{ 'email' => 'chris@example.com' }, { 'email' => 'jesse@stanford.edu' }]
@@ -299,4 +317,35 @@ describe Spotlight::Exhibit, type: :model do
   it 'is expected to be versioned' do
     is_expected.to be_versioned
   end
+  describe 'translatable fields' do
+    let(:persisted_exhibit) { FactoryBot.create(:exhibit, title: 'Sample', subtitle: 'SubSample', description: 'Description') }
+    before do
+      FactoryBot.create(:translation, locale: 'fr', exhibit: persisted_exhibit, key: "#{persisted_exhibit.slug}.title", value: 'Titre français')
+      FactoryBot.create(:translation, locale: 'fr', exhibit: persisted_exhibit, key: "#{persisted_exhibit.slug}.subtitle", value: 'Sous-titre français')
+      FactoryBot.create(:translation, locale: 'fr', exhibit: persisted_exhibit, key: "#{persisted_exhibit.slug}.description", value: 'Description français')
+      Translation.current_exhibit = persisted_exhibit
+    end
+    after do
+      I18n.locale = 'en'
+    end
+    it 'has a translatable title' do
+      expect(persisted_exhibit.title).to eq 'Sample'
+      I18n.locale = 'fr'
+      persisted_exhibit.reload
+      expect(persisted_exhibit.title).to eq 'Titre français'
+    end
+    it 'has a translatable subtitle' do
+      expect(persisted_exhibit.subtitle).to eq 'SubSample'
+      I18n.locale = 'fr'
+      persisted_exhibit.reload
+      expect(persisted_exhibit.subtitle).to eq 'Sous-titre français'
+    end
+
+    it 'has a translatable description' do
+      expect(persisted_exhibit.description).to eq 'Description'
+      I18n.locale = 'fr'
+      persisted_exhibit.reload
+      expect(persisted_exhibit.description).to eq 'Description français'
+    end
+  end
 end

data/spec/models/spotlight/language_spec.rb

@@ -0,0 +1,41 @@
+# 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/page_spec.rb

@@ -111,4 +111,113 @@ describe Spotlight::Page, type: :model do
       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
+    let!(:page_es) { FactoryBot.create(:feature_page, exhibit: exhibit, locale: 'es', default_locale_page: page) }
+    subject!(:page) { FactoryBot.create(:feature_page, exhibit: exhibit) }
+
+    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
+    let(:page) { FactoryBot.create(:feature_page, exhibit: exhibit, published: true) }
+    subject!(:cloned_page) { page.clone_for_locale('es') }
+
+    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 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
+
+    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 'updates the parent page id' 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 '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