hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/services/hyrax/workflow/activate_object_spec.rb

@@ -0,0 +1,26 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::ActivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like "a Hyrax workflow method"
+
+  describe ".call" do
+    it "makes it active" do
+      if RDF::VERSION.to_s < '2.0'
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(instance_of(ActiveTriples::Resource))
+      else
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#active'))
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/changes_required_notification_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Workflow::ChangesRequiredNotification do
+  let(:approver) { create(:user) }
+  let(:depositor) { create(:user) }
+  let(:to_user) { create(:user) }
+  let(:cc_user) { create(:user) }
+  let(:work) { create(:generic_work, user: depositor) }
+  let(:entity) { create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s) }
+  let(:comment) { double("comment", comment: 'A pleasant read') }
+  let(:recipients) { { 'to' => [to_user], 'cc' => [cc_user] } }
+
+  describe ".send_notification" do
+    it 'sends a message to all users' do
+      expect(approver).to receive(:send_message)
+        .with(anything,
+              "Test title (<a href=\"/concern/generic_works/#{work.id}\">#{work.id}</a>) " \
+              "requires additional changes before approval.\n\n 'A pleasant read'",
+              anything).exactly(3).times.and_call_original
+
+      expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+        .to change { depositor.mailbox.inbox.count }.by(1)
+                                                    .and change { to_user.mailbox.inbox.count }.by(1)
+                                                                                               .and change { cc_user.mailbox.inbox.count }.by(1)
+    end
+    context 'without carbon-copied users' do
+      let(:recipients) { { 'to' => [to_user] } }
+
+      it 'sends a message to the to user(s)' do
+        expect(approver).to receive(:send_message).exactly(2).times.and_call_original
+        expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+          .to change { depositor.mailbox.inbox.count }.by(1)
+                                                      .and change { to_user.mailbox.inbox.count }.by(1)
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/deactivate_object_spec.rb

@@ -0,0 +1,26 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::DeactivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like "a Hyrax workflow method"
+
+  describe ".call" do
+    it "makes it inactive" do
+      if RDF::VERSION.to_s < '2.0'
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(instance_of(ActiveTriples::Resource))
+      else
+        expect { described_class.call(target: work, comment: "A pleasant read", user: user) }
+          .to change { work.state }
+          .from(nil)
+          .to(::RDF::URI('http://fedora.info/definitions/1/0/access/ObjState#inactive'))
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/deposited_notification_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Workflow::DepositedNotification do
+  let(:approver) { create(:user) }
+  let(:depositor) { create(:user) }
+  let(:to_user) { create(:user) }
+  let(:cc_user) { create(:user) }
+  let(:work) { create(:generic_work, user: depositor) }
+  let(:entity) { create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s) }
+  let(:comment) { double("comment", comment: 'A pleasant read') }
+  let(:recipients) { { 'to' => [to_user], 'cc' => [cc_user] } }
+
+  describe ".send_notification" do
+    it 'sends a message to all users' do
+      expect(approver).to receive(:send_message)
+        .with(anything,
+              "Test title (<a href=\"/concern/generic_works/#{work.id}\">#{work.id}</a>) " \
+              "was approved by #{approver.user_key}. A pleasant read",
+              anything).exactly(3).times.and_call_original
+
+      expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+        .to change { depositor.mailbox.inbox.count }.by(1)
+                                                    .and change { to_user.mailbox.inbox.count }.by(1)
+                                                                                               .and change { cc_user.mailbox.inbox.count }.by(1)
+    end
+    context 'without carbon-copied users' do
+      let(:recipients) { { 'to' => [to_user] } }
+
+      it 'sends a message to the to user(s)' do
+        expect(approver).to receive(:send_message).exactly(2).times.and_call_original
+        expect { described_class.send_notification(entity: entity, user: approver, comment: comment, recipients: recipients) }
+          .to change { depositor.mailbox.inbox.count }.by(1)
+                                                      .and change { to_user.mailbox.inbox.count }.by(1)
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/grant_edit_to_depositor_spec.rb

@@ -0,0 +1,53 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::GrantEditToDepositor do
+  let(:depositor) { create(:user) }
+  let(:user) { User.new }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like 'a Hyrax workflow method'
+
+  describe ".call" do
+    subject do
+      described_class.call(target: work,
+                           comment: "A pleasant read",
+                           user: user)
+    end
+
+    context "with no additional editors" do
+      let(:work) { create(:work_without_access, depositor: depositor.user_key) }
+
+      it "adds edit access" do
+        expect { subject }.to change { work.edit_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with an additional editor" do
+      let(:editor) { create(:user) }
+      let(:work) { create(:work_without_access, depositor: depositor.user_key, edit_users: [editor.user_key]) }
+
+      it "adds edit access" do
+        expect { subject }.to change { work.edit_users }.from([editor.user_key]).to([editor.user_key, depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with attached FileSets", :perform_enqueued do
+      let(:work) { create(:work_with_one_file, user: depositor) }
+      let(:file_set) do
+        work.members.first.tap do |file_set|
+          # Manually remove edit_users to satisfy the pre-condition
+          file_set.update(edit_users: [])
+        end
+      end
+
+      it "grants edit access" do
+        # We need to reload, because this work happens in a background job
+        expect { subject }.to change { file_set.reload.edit_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/grant_read_to_depositor_spec.rb

@@ -0,0 +1,48 @@
+require 'hyrax/specs/shared_specs'
+
+RSpec.describe Hyrax::Workflow::GrantReadToDepositor do
+  let(:depositor) { create(:user) }
+  let(:user) { User.new }
+
+  let(:workflow_method) { described_class }
+
+  it_behaves_like 'a Hyrax workflow method'
+
+  describe ".call" do
+    subject do
+      described_class.call(target: work,
+                           comment: "A pleasant read",
+                           user: user)
+    end
+
+    context "with no additional viewers" do
+      let(:work) { create(:work_without_access, depositor: depositor.user_key) }
+
+      it "adds read access" do
+        expect { subject }.to change { work.read_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with an additional viewers" do
+      let(:viewer) { create(:user) }
+      let(:work) { create(:work_without_access, depositor: depositor.user_key, read_users: [viewer.user_key]) }
+
+      it "adds read access" do
+        expect { subject }.to change { work.read_users }.from([viewer.user_key]).to([viewer.user_key, depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+
+    context "with attached FileSets", perform_enqueued: [Hyrax::GrantReadToMembersJob] do
+      let(:work) { create(:work_with_one_file, user: depositor) }
+      let(:file_set) { work.members.first }
+
+      it "grants read access" do
+        # We need to reload, because this work happens in a background job
+        expect { subject }.to change { file_set.reload.read_users }.from([]).to([depositor.user_key])
+        expect(work).to be_valid
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/method_generator_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe Hyrax::Workflow::MethodGenerator do
+  describe ".call" do
+    let(:workflow_action) { create(:workflow_action) }
+    let(:method_list) { ['one', 'two'] }
+
+    subject { described_class.call(action: workflow_action, list: method_list) }
+
+    context "when there are no existing methods" do
+      it "creates new methods" do
+        subject
+        expect(workflow_action.triggered_methods).to all(be_kind_of Sipity::Method)
+        expect(workflow_action.triggered_methods.count).to eq 2
+        expect(workflow_action.triggered_methods.map(&:weight)).to eq [0, 1]
+      end
+    end
+
+    context "when there are now fewer methods " do
+      before do
+        workflow_action.triggered_methods.create!(service_name: 'four', weight: 0)
+        workflow_action.triggered_methods.create!(service_name: 'five', weight: 1)
+        workflow_action.triggered_methods.create!(service_name: 'six', weight: 2)
+      end
+
+      it "removes the old methods" do
+        expect { subject }.to change { workflow_action.triggered_methods.count }.from(3).to(2)
+        expect(workflow_action.triggered_methods.map(&:weight)).to eq [0, 1]
+        expect(workflow_action.triggered_methods.map(&:service_name)).to eq ['one', 'two']
+      end
+    end
+
+    context "when there are now more methods " do
+      before do
+        workflow_action.triggered_methods.create!(service_name: 'four', weight: 0)
+      end
+      it "adds the new methods" do
+        expect { subject }.to change { workflow_action.triggered_methods.count }.from(1).to(2)
+        expect(workflow_action.triggered_methods.map(&:weight)).to eq [0, 1]
+        expect(workflow_action.triggered_methods.map(&:service_name)).to eq ['one', 'two']
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/notification_configuration_parameter_spec.rb

@@ -0,0 +1,24 @@
+module Hyrax
+  module Workflow
+    RSpec.describe NotificationConfigurationParameter do
+      describe '#build_from_workflow_action_configuration' do
+        let(:config) do
+          {
+            name: 'name_of_notification', notification_type: Sipity::Notification::NOTIFICATION_TYPE_EMAIL,
+            to: ['role_name_to'], cc: ['role_name_cc'], bcc: ['role_name_bcc']
+          }
+        end
+
+        it 'will build based on the given action' do
+          expected = described_class.new scope: 'name_of_action',
+                                         reason: Sipity::NotifiableContext::REASON_ACTION_IS_TAKEN,
+                                         recipients: { to: config.fetch(:to), cc: config.fetch(:cc), bcc: config.fetch(:bcc) },
+                                         notification_name: config.fetch(:name),
+                                         notification_type: config.fetch(:notification_type)
+          actual = described_class.build_from_workflow_action_configuration(workflow_action: 'name_of_action', config: config)
+          expect(actual).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/notification_generator_spec.rb

@@ -0,0 +1,27 @@
+module Hyrax
+  module Workflow
+    RSpec.describe NotificationGenerator do
+      let(:workflow) { create(:workflow) }
+      let(:recipients) { { to: 'creating_user', cc: 'advising', bcc: "data_observing" } }
+
+      context '#call' do
+        context 'with for a workflow action' do
+          let(:notification_configuration) do
+            NotificationConfigurationParameter.build_from_workflow_action_configuration(
+              workflow_action: 'an_action', config: recipients.merge(name: 'the_weasel', notification_type: 'email')
+            )
+          end
+
+          it 'will generate the requisite entries' do
+            workflow_action = Sipity::WorkflowAction.create!(workflow_id: workflow.id, name: 'an_action')
+            expect do
+              described_class.call(workflow: workflow, notification_configuration: notification_configuration)
+            end.to change { Sipity::Notification.count }.by(1)
+                                                        .and change { Sipity::NotificationRecipient.count }.by(3)
+                                                                                                           .and change { workflow_action.notifiable_contexts.count }.by(1)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/notification_service_spec.rb

@@ -0,0 +1,87 @@
+RSpec.describe Hyrax::Workflow::NotificationService do
+  context 'class methods' do
+    subject { described_class }
+
+    it { is_expected.to respond_to(:deliver_on_action_taken) }
+  end
+
+  let(:creating_user) { Sipity::Role.new(name: 'creating_user') }
+  let(:recipient1) do
+    Sipity::NotificationRecipient.new(recipient_strategy: 'to',
+                                      role: creating_user)
+  end
+  let(:advising) { Sipity::Role.new(name: 'advising') }
+  let(:recipient2) do
+    Sipity::NotificationRecipient.new(recipient_strategy: 'cc',
+                                      role: advising)
+  end
+  let(:notification) do
+    Sipity::Notification.new(name: "confirmation_of_submitted_to_ulra_committee",
+                             recipients: [recipient1, recipient2])
+  end
+  let(:notifiable_context) { Sipity::NotifiableContext.new(notification: notification) }
+  let(:action) { Sipity::WorkflowAction.new(notifiable_contexts: [notifiable_context]) }
+  let(:entity) { Sipity::Entity.new }
+  let(:user) { User.new }
+  let(:instance) do
+    described_class.new(entity: entity,
+                        action: action,
+                        comment: "A pleasant read",
+                        user: user)
+  end
+
+  describe "#call" do
+    subject { instance.call }
+
+    context "when the notification exists" do
+      around do |example|
+        class ConfirmationOfSubmittedToUlraCommittee
+          def self.send_notification; end
+        end
+        example.run
+        Object.send(:remove_const, :ConfirmationOfSubmittedToUlraCommittee)
+      end
+
+      let(:advisors) { [instance_double(User), instance_double(User)] }
+      let(:creator) { [instance_double(User)] }
+      let(:advisor_rel) { double(ActiveRecord::Relation, to_ary: advisors) }
+      let(:creator_rel) { double(ActiveRecord::Relation, to_ary: creator) }
+
+      before do
+        allow(Hyrax::Workflow::PermissionQuery).to receive(:scope_users_for_entity_and_roles)
+          .with(entity: entity,
+                roles: advising)
+          .and_return(advisor_rel)
+
+        allow(Hyrax::Workflow::PermissionQuery).to receive(:scope_users_for_entity_and_roles)
+          .with(entity: entity,
+                roles: creating_user)
+          .and_return(creator_rel)
+      end
+
+      it "calls the notification" do
+        expect(ConfirmationOfSubmittedToUlraCommittee).to receive(:send_notification).with(hash_including(recipients: { "to" => creator, 'cc' => advisors }))
+        subject
+      end
+    end
+
+    context "when the notification class doesn't have the method" do
+      around do |example|
+        class ConfirmationOfSubmittedToUlraCommittee; end
+        example.run
+        Object.send(:remove_const, :ConfirmationOfSubmittedToUlraCommittee)
+      end
+      it "logs an error" do
+        expect(Rails.logger).to receive(:error).with("Expected 'ConfirmationOfSubmittedToUlraCommittee' to respond to 'send_notification', but it didn't, so not sending notification")
+        subject
+      end
+    end
+
+    context "when the notification doesn't exist" do
+      it "logs an error" do
+        expect(Rails.logger).to receive(:error).with("Unable to find 'ConfirmationOfSubmittedToUlraCommittee', so not sending notification")
+        subject
+      end
+    end
+  end
+end

data/spec/services/hyrax/workflow/pending_review_notification_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe Hyrax::Workflow::PendingReviewNotification do
+  let(:depositor) { create(:user) }
+  let(:to_user) { create(:user) }
+  let(:cc_user) { create(:user) }
+  let(:work) { create(:generic_work, user: depositor) }
+  let(:entity) { create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s) }
+  let(:comment) { double("comment", comment: 'A pleasant read') }
+  let(:recipients) { { 'to' => [to_user], 'cc' => [cc_user] } }
+
+  describe ".send_notification" do
+    it 'sends a message to all users except depositor' do
+      expect(depositor).to receive(:send_message)
+        .with(anything,
+              "Test title (<a href=\"/concern/generic_works/#{work.id}\">#{work.id}</a>) "\
+              "was deposited by #{depositor.user_key} and is awaiting approval A pleasant read",
+              anything).exactly(3).times.and_call_original
+
+      expect { described_class.send_notification(entity: entity, user: depositor, comment: comment, recipients: recipients) }
+        .to change { depositor.mailbox.inbox.count }.by(1)
+                                                    .and change { to_user.mailbox.inbox.count }.by(1)
+                                                                                               .and change { cc_user.mailbox.inbox.count }.by(1)
+    end
+    context 'without carbon-copied users' do
+      let(:recipients) { { 'to' => [to_user] } }
+
+      it 'sends a message to the to user(s)' do
+        expect(depositor).to receive(:send_message).exactly(2).times.and_call_original
+        expect { described_class.send_notification(entity: entity, user: depositor, comment: comment, recipients: recipients) }
+          .to change { depositor.mailbox.inbox.count }.by(1)
+                                                      .and change { to_user.mailbox.inbox.count }.by(1)
+      end
+    end
+  end
+end