hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/models/sipity/workflow_spec.rb

@@ -0,0 +1,84 @@
+module Sipity
+  RSpec.describe Workflow, type: :model do
+    context 'class configuration' do
+      subject { described_class }
+
+      its(:column_names) { is_expected.to include('name') }
+    end
+
+    subject { create(:workflow, name: 'ETD Workflow') }
+
+    it { is_expected.to belong_to(:permission_template) }
+
+    context '#initial_workflow_state' do
+      it 'will create a state if one does not exist' do
+        expect { subject.initial_workflow_state }
+          .to change { subject.workflow_states.count }.by(1)
+      end
+    end
+
+    context '.activate!' do
+      let!(:permission_template) { create(:permission_template) }
+      let!(:other_permission_template) { create(:permission_template) }
+      let!(:active_workflow) { create(:workflow, active: true, permission_template_id: permission_template.id) }
+
+      context 'selecting already active workflow' do
+        it 'makes no change' do
+          inactive_workflow = create(:workflow, permission_template_id: permission_template.id)
+          described_class.activate!(permission_template: permission_template, workflow_id: active_workflow.id)
+          expect(active_workflow.reload).to be_active
+          expect(inactive_workflow.reload).not_to be_active
+        end
+      end
+
+      it 'raises an exception if you do not pass a workflow_id nor workflow_name' do
+        expect do
+          described_class.activate!(permission_template: other_permission_template)
+        end.to raise_error(RuntimeError)
+      end
+      it 'raises an exception on a mismatch' do
+        expect do
+          described_class.activate!(permission_template: other_permission_template, workflow_id: active_workflow.id)
+        end.to raise_error(ActiveRecord::RecordNotFound)
+      end
+      context 'with :workflow_id keyword' do
+        it 'activates the specified workflow and deactivates the unspecified workflow for the permission_template' do
+          active_workflow_wrong_template = create(:workflow, active: true, permission_template_id: other_permission_template.id)
+          inactive_workflow = create(:workflow, permission_template_id: permission_template.id)
+
+          described_class.activate!(permission_template: permission_template, workflow_id: inactive_workflow)
+          expect(inactive_workflow.reload).to be_active
+          expect(active_workflow.reload).not_to be_active
+          expect(active_workflow_wrong_template.reload).to be_active
+        end
+      end
+      context 'with :workflow_name keyword' do
+        it 'activates the specified workflow and deactivates the unspecified workflow for the permission_template' do
+          active_workflow_wrong_template = create(:workflow, active: true, permission_template_id: other_permission_template.id)
+          inactive_workflow = create(:workflow, permission_template_id: permission_template.id)
+
+          described_class.activate!(permission_template: permission_template, workflow_name: inactive_workflow.name)
+          expect(inactive_workflow.reload).to be_active
+          expect(active_workflow.reload).not_to be_active
+          expect(active_workflow_wrong_template.reload).to be_active
+        end
+      end
+    end
+
+    context '.find_active_workflow_for' do
+      let(:source_id) { 1234 }
+      let(:permission_template) { create(:permission_template, source_id: source_id) }
+
+      it 'returns the active workflow for the permission template' do
+        active_workflow = create(:workflow, active: true, permission_template: permission_template)
+        _inactive_workflow = create(:workflow, active: false, permission_template: permission_template)
+        expect(described_class.find_active_workflow_for(admin_set_id: source_id)).to eq(active_workflow)
+      end
+
+      it 'raises an exception when none exists' do
+        create(:workflow, active: false, permission_template: permission_template)
+        expect { described_class.find_active_workflow_for(admin_set_id: source_id) }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end

data/spec/models/sipity/workflow_state_action_permission_spec.rb

@@ -0,0 +1,8 @@
+module Sipity
+  RSpec.describe WorkflowStateActionPermission, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include("workflow_role_id") }
+    its(:column_names) { is_expected.to include("workflow_state_action_id") }
+  end
+end

data/spec/models/sipity/workflow_state_action_spec.rb

@@ -0,0 +1,8 @@
+module Sipity
+  RSpec.describe WorkflowStateAction, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include("originating_workflow_state_id") }
+    its(:column_names) { is_expected.to include("workflow_action_id") }
+  end
+end

data/spec/models/sipity/workflow_state_spec.rb

@@ -0,0 +1,17 @@
+module Sipity
+  RSpec.describe WorkflowState, type: :model do
+    subject { described_class }
+
+    its(:column_names) { is_expected.to include("workflow_id") }
+    its(:column_names) { is_expected.to include("name") }
+
+    describe "#entities" do
+      let(:workflow_state) { create(:workflow_state, name: 'test') }
+      let!(:entity)        { Sipity::Entity.create!(workflow_state: workflow_state, proxy_for_global_id: "abc123", workflow_id: workflow_state.workflow_id) }
+
+      it "has entites" do
+        expect(workflow_state.entities).to match_array([entity])
+      end
+    end
+  end
+end

data/spec/models/solr_document_spec.rb

@@ -0,0 +1,205 @@
+RSpec.describe ::SolrDocument, type: :model do
+  let(:document) { described_class.new(attributes) }
+  let(:attributes) { {} }
+
+  describe "#itemtype" do
+    let(:attributes) { { resource_type_tesim: ['Article'] } }
+
+    it "delegates to the Hyrax::ResourceTypesService" do
+      expect(Hyrax::ResourceTypesService).to receive(:microdata_type).with('Article')
+      subject
+    end
+    subject { document.itemtype }
+
+    it { is_expected.to eq 'http://schema.org/Article' }
+
+    context 'with no resource_type' do
+      let(:attributes) { {} }
+
+      it { is_expected.to eq 'http://schema.org/CreativeWork' }
+    end
+  end
+
+  describe "date_uploaded" do
+    let(:attributes) { { 'date_uploaded_dtsi' => '2013-03-14T00:00:00Z' } }
+
+    subject { document.date_uploaded }
+
+    it { is_expected.to eq Date.parse('2013-03-14') }
+
+    context "when an invalid type is provided" do
+      let(:attributes) { { 'date_uploaded_dtsi' => 'Test' } }
+
+      it "logs parse errors" do
+        expect(Hyrax.logger).to receive(:info).with(/Unable to parse date.*/)
+        subject
+      end
+    end
+  end
+
+  describe "rights_statement" do
+    let(:attributes) { { 'rights_statement_tesim' => ['A rights statement'] } }
+
+    it "responds to rights_statement" do
+      expect(document).to respond_to(:rights_statement)
+    end
+    it "returns the proper data" do
+      expect(document.rights_statement).to eq ['A rights statement']
+    end
+  end
+
+  describe "create_date" do
+    let(:attributes) { { 'system_create_dtsi' => '2013-03-14T00:00:00Z' } }
+
+    subject { document.create_date }
+
+    it { is_expected.to eq Date.parse('2013-03-14') }
+
+    context "when an invalid type is provided" do
+      let(:attributes) { { 'system_create_dtsi' => 'Test' } }
+
+      it "logs parse errors" do
+        expect(Hyrax.logger).to receive(:info).with(/Unable to parse date.*/)
+        subject
+      end
+    end
+  end
+
+  describe "resource_type" do
+    let(:attributes) { { 'resource_type_tesim' => ['Image'] } }
+
+    subject { document.resource_type }
+
+    it { is_expected.to eq ['Image'] }
+  end
+
+  describe "thumbnail_path" do
+    let(:attributes) { { 'thumbnail_path_ss' => ['/foo/bar'] } }
+
+    subject { document.thumbnail_path }
+
+    it { is_expected.to eq '/foo/bar' }
+  end
+
+  describe '#to_param' do
+    let(:id) { '1v53kn56d' }
+    let(:attributes) { { id: id } }
+
+    subject { document.to_param }
+
+    it { is_expected.to eq id }
+  end
+
+  describe "#suppressed?" do
+    let(:attributes) { { 'suppressed_bsi' => suppressed_value } }
+
+    subject { document }
+
+    context 'when true' do
+      let(:suppressed_value) { true }
+
+      it { is_expected.to be_suppressed }
+    end
+    context 'when false' do
+      let(:suppressed_value) { false }
+
+      it { is_expected.not_to be_suppressed }
+    end
+  end
+  describe "document types" do
+    class Mimes
+      include Hydra::Works::MimeTypes
+    end
+
+    Mimes.office_document_mime_types.each do |type|
+      context "when mime-type is #{type}" do
+        let(:attributes) { { 'mime_type_ssi' => type } }
+
+        subject { document }
+
+        it { is_expected.to be_office_document }
+      end
+    end
+
+    Mimes.video_mime_types.each do |type|
+      context "when mime-type is #{type}" do
+        let(:attributes) { { 'mime_type_ssi' => type } }
+
+        subject { document }
+
+        it { is_expected.to be_video }
+      end
+    end
+  end
+
+  describe '#collection_ids' do
+    subject { document.collection_ids }
+
+    context 'when the object belongs to collections' do
+      let(:attributes) do
+        { id: '123',
+          title_tesim: ['A generic work'],
+          collection_ids_tesim: ['123', '456', '789'] }
+      end
+
+      it { is_expected.to eq ['123', '456', '789'] }
+    end
+
+    context 'when the object does not belong to any collections' do
+      let(:attributes) do
+        { id: '123',
+          title_tesim: ['A generic work'] }
+      end
+
+      it { is_expected.to eq [] }
+    end
+  end
+
+  describe "#height" do
+    let(:attributes) { { height_is: '444' } }
+
+    subject { document.height }
+
+    it { is_expected.to eq '444' }
+  end
+
+  describe "#width" do
+    let(:attributes) { { width_is: '555' } }
+
+    subject { document.width }
+
+    it { is_expected.to eq '555' }
+  end
+
+  context "when exporting in endnote format" do
+    let(:attributes) { { id: "1234" } }
+
+    subject { document.endnote_filename }
+
+    it { is_expected.to eq("1234.endnote") }
+  end
+
+  describe "#admin_set?" do
+    let(:attributes) { { 'has_model_ssim' => 'AdminSet' } }
+
+    subject { document }
+
+    it { is_expected.to be_admin_set }
+  end
+
+  describe "#collection?" do
+    let(:attributes) { { 'has_model_ssim' => 'Collection' } }
+
+    subject { document }
+
+    it { is_expected.to be_collection }
+  end
+
+  describe "#collection_type_gid?" do
+    let(:attributes) { { 'collection_type_gid_ssim' => 'gid://internal/hyrax-collectiontype/5' } }
+
+    subject { document.collection_type_gid }
+
+    it { is_expected.to eq 'gid://internal/hyrax-collectiontype/5' }
+  end
+end

data/spec/models/trophy_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Trophy, type: :model do
+  let(:trophy) { described_class.create(user_id: 99, work_id: "99") }
+
+  it "has a user" do
+    expect(trophy).to respond_to(:user_id)
+    expect(trophy.user_id).to eq(99)
+  end
+
+  it "has a work" do
+    expect(trophy).to respond_to(:work_id)
+    expect(trophy.work_id).to eq("99")
+  end
+
+  it "does not allow six trophies" do
+    (1..6).each { |n| described_class.create(user_id: 120, work_id: n.to_s) }
+    expect(described_class.where(user_id: 120).count).to eq(5)
+    described_class.where(user_id: 120).map(&:delete)
+  end
+end

data/spec/models/user_mailbox_spec.rb

@@ -0,0 +1,134 @@
+RSpec.describe UserMailbox do
+  let(:user)         { create(:user) }
+  let(:another_user) { create(:user) }
+
+  before do
+    another_user.send_message(user, "Test Message", "Test Subject")
+    user.send_message(another_user, "Test Message", "Test Subject")
+  end
+
+  subject { described_class.new(user) }
+
+  describe "#inbox" do
+    subject { described_class.new(user).inbox.first.last_message }
+
+    it "has mail" do
+      expect(subject.body).to eq('Test Message')
+      expect(subject.subject).to eq('Test Subject')
+      expect(user.mailbox.inbox(unread: true).count).to eq(0)
+    end
+  end
+
+  describe '#unread_count' do
+    it 'returns the number of unread messages for a user' do
+      expect { another_user.send_message(user, 'Another Test', '[subj]') }
+        .to change { subject.unread_count }.from(1).to(2)
+    end
+  end
+
+  describe '#label' do
+    # rubocop:disable RSpec/SubjectStub
+    before do
+      allow(subject).to receive(:unread_count).and_return(count)
+    end
+    # rubocop:enable RSpec/SubjectStub
+
+    context 'with zero unread messages' do
+      let(:count) { 0 }
+
+      it 'returns the appropriate label' do
+        expect(subject.label).to eq 'You have no unread notifications'
+      end
+    end
+
+    context 'with one unread message' do
+      let(:count) { 1 }
+
+      it 'returns the appropriate label' do
+        expect(subject.label).to eq 'You have one unread notification'
+      end
+    end
+
+    context 'with multiple unread messages' do
+      let(:count) { 5 }
+
+      it 'returns the appropriate label' do
+        expect(subject.label).to eq 'You have 5 unread notifications'
+      end
+    end
+
+    describe 'locales' do
+      let(:count) { 3 }
+
+      context 'when param is passed' do
+        it 'returns the label in the specified locale' do
+          expect(subject.label('es')).to eq 'Tienes notificaciones no leídas de 3'
+        end
+      end
+
+      context 'when param is not passed' do
+        before { allow(user).to receive(:preferred_locale).and_return(preferred_locale) }
+
+        context 'when user has a preferred locale' do
+          let(:preferred_locale) { 'it' }
+
+          it 'returns the label in the user-preferred locale' do
+            expect(I18n).not_to receive(:default_locale)
+            expect(subject.label).to eq 'Hai notifiche non letti 3'
+          end
+        end
+
+        context 'when user lacks a preferred locale' do
+          let(:preferred_locale) { nil }
+
+          it 'returns the system default locale' do
+            expect(I18n).to receive(:default_locale).once.and_return('de')
+            expect(subject.label).to eq 'Sie haben 3 ungelesene Benachrichtigungen'
+          end
+        end
+      end
+    end
+  end
+
+  describe "#delete_all" do
+    before do
+      another_user.send_message(user, 'message 2', 'subject 2')
+      another_user.send_message(user, 'message 3', 'subject 3')
+    end
+    it "deletes all messages" do
+      expect(user.mailbox.inbox.count).to eq(3)
+      subject.delete_all
+      expect(user.mailbox.inbox.count).to eq(0)
+    end
+  end
+
+  describe "#delete" do
+    let(:rec)         { another_user.send_message(user, 'message 2', 'subject 2') }
+    let!(:message_id) { rec.conversation.id }
+
+    it "deletes a message" do
+      subject.destroy message_id
+      expect { Mailboxer::Conversation.find(message_id) }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    context "non-existing conversation" do
+      let!(:message_id) { -99 }
+
+      it "raises an error" do
+        expect { subject.destroy message_id }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    context "deleting a message from a third party" do
+      let(:curator)     { create(:user) }
+      let(:message)     { another_user.send_message(curator, 'message 3', 'subject 3') }
+      let!(:message_id) { message.conversation.id }
+
+      it "does not delete the message" do
+        subject.destroy message_id
+        expect(subject.destroy(message_id)).to eq "You do not have privileges to delete the notification..."
+        expect(Mailboxer::Conversation.find(message_id).id).to eq message_id
+      end
+    end
+  end
+end