test_hyrax 0.0.1.alpha

data/spec/services/hyrax/versioning_service_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Hyrax::VersioningService do
+  describe '#latest_version_of' do
+    let(:file) do
+      FileSet.create do |f|
+        f.apply_depositor_metadata('mjg36')
+      end
+    end
+
+    before do
+      # Add the original_file (this service  creates a version after saving when you call it with versioning: true)
+      Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file, versioning: true)
+    end
+
+    describe 'latest_version_of' do
+      subject { described_class.latest_version_of(file.original_file).label }
+
+      context 'with one version' do
+        it { is_expected.to eq 'version1' }
+      end
+
+      context 'with two versions' do
+        before do
+          file.original_file.create_version
+        end
+        it { is_expected.to eq 'version2' }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::Workflow::ActionTakenService do
+  context 'class methods' do
+    subject { described_class }
+    it { is_expected.to respond_to(:handle_action_taken) }
+  end
+
+  let(:triggered_methods) { [instance_double(Sipity::Method, service_name: 'FooBar')] }
+  let(:triggered_methods_rel) do
+    instance_double(Sipity::Method::ActiveRecord_Relation,
+                    order: triggered_methods,
+                    any?: true)
+  end
+  let(:work) { instance_double(GenericWork, id: '9999') }
+  let(:action) { instance_double(Sipity::WorkflowAction, triggered_methods: triggered_methods_rel) }
+  let(:user) { User.new }
+  let(:instance) do
+    described_class.new(target: work,
+                        action: action,
+                        comment: "A pleasant read",
+                        user: user)
+  end
+
+  describe "#call" do
+    subject { instance.call }
+    context "when the method exists" do
+      around do |example|
+        class FooBar
+          def self.call; end
+        end
+        example.run
+        Object.send(:remove_const, :FooBar)
+      end
+
+      context "and the method succeedes" do
+        it "calls the method and saves the object" do
+          expect(work).to receive(:save)
+          expect(FooBar).to receive(:call).with(target: work, user: user, comment: "A pleasant read").and_return(true)
+          subject
+        end
+      end
+      context "and the method fails" do
+        it "calls the method and saves the object" do
+          expect(work).not_to receive(:save)
+          expect(FooBar).to receive(:call).with(target: work, user: user, comment: "A pleasant read").and_return(false)
+          expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+          subject
+        end
+      end
+    end
+
+    context "when the notification class doesn't have the method" do
+      around do |example|
+        class FooBar; end
+        example.run
+        Object.send(:remove_const, :FooBar)
+      end
+      it "logs an error" do
+        expect(Rails.logger).to receive(:error).with("Expected 'FooBar' to respond to 'call', but it didn't, so not running workflow callback")
+        expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+        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 'FooBar', so not running workflow callback")
+        expect(Rails.logger).to receive(:error).with("Not all workflow methods were successful, so not saving (9999)")
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::Workflow::ActivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  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,36 @@
+require 'spec_helper'
+
+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).once.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).once.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,22 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::Workflow::DeactivateObject do
+  let(:work) { create(:generic_work) }
+  let(:user) { create(:user) }
+
+  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,36 @@
+require 'spec_helper'
+
+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).once.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).once.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,20 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::Workflow::GrantEditToDepositor do
+  let(:depositor) { create(:user) }
+  let(:work) { create(:work_without_access, depositor: depositor.user_key) }
+  let(:user) { User.new }
+
+  describe ".call" do
+    subject do
+      described_class.call(target: work,
+                           comment: "A pleasant read",
+                           user: user)
+    end
+
+    it "adds edit access " do
+      expect { subject }.to change { work.edit_users }.from([]).to([depositor.user_key])
+      expect(work).to be_valid
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+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,25 @@
+require 'spec_helper'
+
+module Hyrax
+  module Workflow
+    RSpec.describe NotificationConfigurationParameter, no_clean: true 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 @@
+require 'spec_helper'
+module Hyrax
+  module Workflow
+    RSpec.describe NotificationGenerator, no_clean: true do
+      let(:workflow) { Sipity::Workflow.new(id: 1) }
+      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,88 @@
+require 'spec_helper'
+
+RSpec.describe Hyrax::Workflow::NotificationService, :no_clean 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,35 @@
+require 'spec_helper'
+
+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).once.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).once.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