hyrax 2.6.0 → 2.9.0

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

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

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

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

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

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

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

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

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

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

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

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