hyrax 2.6.0 → 2.9.0

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

@@ -1,50 +0,0 @@
-module Hyrax
-  module Workflow
-    RSpec.describe PermissionGenerator do
-      let(:user) { create(:user) }
-      let(:role) { Sipity::Role.create!(name: 'creating_user') }
-      let(:workflow) { create(:workflow, name: 'workflow') }
-      let(:workflow_state) { workflow.initial_workflow_state }
-      let(:entity) do
-        Sipity::Entity.create!(proxy_for_global_id: "gid://work/1", workflow: workflow, workflow_state: workflow_state)
-      end
-      let(:another_entity) do
-        Sipity::Entity.create!(proxy_for_global_id: "gid://work/2", workflow: workflow, workflow_state: workflow_state)
-      end
-      let(:action_name) { 'show' }
-
-      it 'will grant workflow responsible to agent as the given role' do
-        expect do
-          described_class.call(agents: user, roles: role.name, workflow: workflow)
-        end.to change { Sipity::WorkflowRole.count }.by(1)
-                                                    .and change { Sipity::WorkflowResponsibility.count }.by(1)
-      end
-
-      it 'will grant entity responsiblity to agent as the given role' do
-        expect do
-          described_class.call(agents: user, roles: role.name, workflow: workflow, entity: entity)
-        end.to change { Sipity::WorkflowRole.count }.by(1)
-                                                    .and change { Sipity::EntitySpecificResponsibility.count }.by(1)
-                                                                                                              .and change { Sipity::WorkflowResponsibility.count }.by(0)
-      end
-
-      it 'will be idempotent' do
-        builder = lambda do
-          described_class.call(
-            agents: user,
-            roles: role.name,
-            entity: entity,
-            workflow: workflow,
-            workflow_state: workflow_state,
-            action_names: action_name
-          )
-        end
-        builder.call
-        [:update_attribute, :update_attributes, :update_attributes!, :save, :save!, :update, :update!].each do |method_names|
-          expect_any_instance_of(ActiveRecord::Base).not_to receive(method_names)
-        end
-        builder.call
-      end
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-module Hyrax
-  module Workflow
-    RSpec.describe PermissionQuery, slow_test: true do
-      let(:reviewing_user) { create(:user) }
-      let(:completing_user) { create(:user) }
-      let(:workflow_config) do
-        {
-          workflows: [{
-            name: 'testing',
-            actions: [{
-              name: "forward", from_states: [{ names: ["initial"], roles: ["reviewing"] }], transition_to: 'forwarded'
-            }, {
-              name: "complete", from_states: [{ names: ["forwarded"], roles: ["completing"] }], transition_to: 'completed'
-            }]
-          }]
-        }
-      end
-
-      let(:sipity_entity) do
-        Sipity::Entity.create!(proxy_for_global_id: 'gid://internal/Mock/1',
-                               workflow: sipity_workflow,
-                               workflow_state: PowerConverter.convert_to_sipity_workflow_state('initial', scope: sipity_workflow))
-      end
-      let(:sipity_workflow) { create(:workflow, name: 'testing') }
-
-      before { Hyrax::Workflow::WorkflowImporter.generate_from_hash(data: workflow_config, permission_template: sipity_workflow.permission_template) }
-
-      def expect_actions_for(user:, entity:, actions:)
-        actions = Array.wrap(actions).map { |action| PowerConverter.convert_to_sipity_action(action, scope: entity.workflow) }
-        expect(described_class.scope_permitted_workflow_actions_available_for_current_state(user: user, entity: entity)).to eq(actions)
-      end
-
-      def expect_agents_for(agents:, entity:, role:)
-        agents = Array.wrap(agents).map { |agent| PowerConverter.convert_to_sipity_agent(agent) }
-        expect(described_class.scope_agents_associated_with_entity_and_role(role: role, entity: entity)).to eq(agents)
-      end
-
-      def expect_roles_for(entity:, roles:)
-        roles = Array.wrap(roles).map { |role| PowerConverter.convert_to_sipity_role(role) }
-        expect(described_class.scope_roles_associated_with_the_given_entity(entity: entity)).to eq(roles)
-      end
-
-      def expect_users_for(entity:, roles:, users:)
-        expect(described_class.scope_users_for_entity_and_roles(entity: entity, roles: roles)).to eq(Array.wrap(users))
-      end
-
-      def expect_to_be_authorized(user:, entity:, action:, message: 'should be authorized')
-        expect(described_class.authorized_for_processing?(user: user, entity: entity, action: action)).to be_truthy, message
-      end
-
-      def expect_to_not_be_authorized(user:, entity:, action:, message: 'should not be authorized')
-        expect(described_class.authorized_for_processing?(user: user, entity: entity, action: action)).to be_falsey, message
-      end
-
-      def expect_entities_for(user:, entities:)
-        entities = Array.wrap(entities).map { |entity| PowerConverter.convert(entity, to: :sipity_entity) }
-        expect(described_class.scope_entities_for_the_user(user: user)).to eq(entities)
-      end
-
-      describe 'entity_responsibilities' do
-        it 'is a Sipity::EntitySpecificResponsibility.arel_table' do
-          expect(described_class.entity_responsibilities).to be_an_instance_of Arel::Table
-        end
-      end
-
-      describe 'workflow_responsibilities' do
-        it 'is a Sipity::WorkflowResponsibility.arel_table' do
-          expect(described_class.workflow_responsibilities).to be_an_instance_of Arel::Table
-        end
-      end
-
-      describe 'workflow_roles' do
-        it 'is a Sipity::WorkflowRole.arel_table' do
-          expect(described_class.workflow_roles).to be_an_instance_of Arel::Table
-        end
-      end
-
-      describe 'permissions assigned at the workflow level' do
-        let(:reviewing_group_member) { create(:user) }
-        let(:reviewing_group) { Group.new('librarians') }
-
-        before do
-          allow(reviewing_group_member).to receive(:groups).and_return(['librarians'])
-          PermissionGenerator.call(roles: 'reviewing', workflow: sipity_workflow, agents: reviewing_user)
-          PermissionGenerator.call(roles: 'reviewing', workflow: sipity_workflow, agents: reviewing_group)
-          PermissionGenerator.call(roles: 'completing', workflow: sipity_workflow, agents: completing_user)
-        end
-
-        it 'will fullfil the battery of tests (of which they are nested because setup is expensive)' do
-          expect_agents_for(entity: sipity_entity, role: 'reviewing', agents: [reviewing_user, reviewing_group])
-          expect_agents_for(entity: sipity_entity, role: 'completing', agents: [completing_user])
-
-          expect_actions_for(user: reviewing_user, entity: sipity_entity, actions: ['forward'])
-          expect_actions_for(user: reviewing_group_member, entity: sipity_entity, actions: ['forward'])
-          expect_actions_for(user: completing_user, entity: sipity_entity, actions: [])
-
-          expect_users_for(users: reviewing_user, entity: sipity_entity, roles: 'reviewing')
-          expect_users_for(users: completing_user, entity: sipity_entity, roles: 'completing')
-
-          expect_entities_for(user: reviewing_user, entities: [sipity_entity])
-          expect_entities_for(user: completing_user, entities: [])
-
-          expect_roles_for(entity: sipity_entity, roles: ['reviewing', 'completing'])
-
-          expect_to_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'forward')
-          expect_to_not_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'complete')
-          expect_to_not_be_authorized(user: completing_user, entity: sipity_entity, action: 'forward')
-          expect_to_not_be_authorized user: completing_user, entity: sipity_entity, action: 'complete',
-                                      message: 'should be unauthorized because the action is not available in this state'
-
-          # Then transition to Sipity::Entity
-          sipity_entity.update!(
-            workflow_state: PowerConverter.convert_to_sipity_workflow_state('forwarded', scope: sipity_workflow)
-          )
-
-          # Now permissions have changed
-          expect_actions_for(user: reviewing_user, entity: sipity_entity, actions: [])
-          expect_actions_for(user: completing_user, entity: sipity_entity, actions: ['complete'])
-
-          expect_to_not_be_authorized user: reviewing_user, entity: sipity_entity, action: 'forward',
-                                      message: 'should be unauthorized because the action is not available in this state'
-          expect_to_not_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'complete')
-          expect_to_not_be_authorized(user: completing_user, entity: sipity_entity, action: 'forward')
-          expect_to_be_authorized(user: completing_user, entity: sipity_entity, action: 'complete')
-
-          expect_entities_for(user: reviewing_user, entities: [])
-          expect_entities_for(user: completing_user, entities: [sipity_entity])
-        end
-      end
-
-      # NOTE: I am stacking up expectations because these tests are non-trivial to build (lots of database interactions)
-      describe 'permissions assigned at the entity level' do
-        it 'will fullfil the battery of tests (of which they are nested because setup is expensive)' do
-          PermissionGenerator.call(roles: 'reviewing', entity: sipity_entity, workflow: sipity_workflow, agents: reviewing_user)
-          PermissionGenerator.call(roles: 'completing', entity: sipity_entity, workflow: sipity_workflow, agents: completing_user)
-
-          expect_agents_for(entity: sipity_entity, role: 'reviewing', agents: [reviewing_user])
-          expect_agents_for(entity: sipity_entity, role: 'completing', agents: [completing_user])
-
-          expect_actions_for(user: reviewing_user, entity: sipity_entity, actions: ['forward'])
-          expect_actions_for(user: completing_user, entity: sipity_entity, actions: [])
-
-          expect_users_for(users: reviewing_user, entity: sipity_entity, roles: 'reviewing')
-          expect_users_for(users: completing_user, entity: sipity_entity, roles: 'completing')
-
-          expect_entities_for(user: reviewing_user, entities: [sipity_entity])
-          expect_entities_for(user: completing_user, entities: [])
-
-          expect_roles_for(entity: sipity_entity, roles: ['reviewing', 'completing'])
-
-          expect_to_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'forward')
-          expect_to_not_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'complete')
-          expect_to_not_be_authorized(user: completing_user, entity: sipity_entity, action: 'forward')
-          expect_to_not_be_authorized user: completing_user, entity: sipity_entity, action: 'complete',
-                                      message: 'should be unauthorized because the action is not available in this state'
-
-          # Then transition to Sipity::Entity
-          sipity_entity.update!(
-            workflow_state: PowerConverter.convert_to_sipity_workflow_state('forwarded', scope: sipity_workflow)
-          )
-
-          # Now permissions have changed
-          expect_actions_for(user: reviewing_user, entity: sipity_entity, actions: [])
-          expect_actions_for(user: completing_user, entity: sipity_entity, actions: ['complete'])
-
-          expect_to_not_be_authorized user: reviewing_user, entity: sipity_entity, action: 'forward',
-                                      message: 'should be unauthorized because the action is not available in this state'
-          expect_to_not_be_authorized(user: reviewing_user, entity: sipity_entity, action: 'complete')
-          expect_to_not_be_authorized(user: completing_user, entity: sipity_entity, action: 'forward')
-          expect_to_be_authorized(user: completing_user, entity: sipity_entity, action: 'complete')
-
-          expect_entities_for(user: reviewing_user, entities: [])
-          expect_entities_for(user: completing_user, entities: [sipity_entity])
-        end
-      end
-
-      describe '.scope_processing_agents_for' do
-        context 'when user is not persisted' do
-          subject { described_class.scope_processing_agents_for(user: ::User.new) }
-
-          it { is_expected.to eq([]) }
-        end
-        context 'when user is non-trivial' do
-          subject { described_class.scope_processing_agents_for(user: nil) }
-
-          it { is_expected.to eq([]) }
-        end
-
-        context 'when user is persisted' do
-          let(:user) { create(:user) }
-
-          before do
-            allow(user).to receive(:groups).and_return(['librarians'])
-          end
-
-          subject { described_class.scope_processing_agents_for(user: user) }
-
-          it 'will equal [kind_of(Sipity::Agent)]' do
-            is_expected.to contain_exactly(PowerConverter.convert_to_sipity_agent(user),
-                                           PowerConverter.convert_to_sipity_agent(Group.new('librarians')))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'hyrax/specs/shared_specs'
-
-RSpec.describe Hyrax::Workflow::RevokeEditFromDepositor 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, edit_users: [depositor.user_key]) }
-
-      it "removes edit access" do
-        expect { subject }.to change { work.edit_users }.from([depositor.user_key]).to([])
-        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: [depositor.user_key, editor.user_key]) }
-
-      it "removes edit access" do
-        expect { subject }.to change { work.edit_users }.from([depositor.user_key, editor.user_key]).to([editor.user_key])
-        expect(work).to be_valid
-      end
-    end
-
-    context "with attached FileSets", perform_enqueued: [Hyrax::RevokeEditFromMembersJob] do
-      let(:work) { create(:work_with_one_file, user: depositor) }
-      let(:file_set) { work.members.first }
-
-      it "removes 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([depositor.user_key]).to([])
-        expect(work).to be_valid
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Hyrax
-  module Workflow
-    RSpec.describe SipityActionsGenerator do
-      let(:workflow) { Sipity::Workflow.new(name: 'Hello') }
-      let(:actions_configuration) do
-        [
-          {
-            name: "start_a_submission", transition_to: "new", emails: [
-              { name: "confirmation_of_ulra_submission_started", to: "creating_user" }
-            ]
-          }, {
-            name: "submit", transition_to: "done", from_states: [{ names: ["new"], roles: ["submitting"] }]
-          }
-        ]
-      end
-
-      let(:new_actions_configuration) do
-        [
-          {
-            name: "submit", transition_to: "done", from_states: [{ names: ["new"], roles: ["submitting"] }]
-          }
-        ]
-      end
-
-      context '.call' do
-        it 'is a convenience method' do
-          expect_any_instance_of(described_class).to receive(:call)
-          described_class.call(workflow: workflow, actions_configuration: actions_configuration)
-        end
-      end
-
-      subject { described_class.new(workflow: workflow, actions_configuration: actions_configuration) }
-
-      it 'parses the actions_configuration and calls the underlying DataGenerators::StateMachineGenerator' do
-        allow_any_instance_of(StateMachineGenerator).to receive(:call)
-        subject.call
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module Hyrax
-  RSpec.describe Workflow::StateMachineGenerator do
-    let(:workflow) { create(:workflow, name: 'hello') }
-    let(:action_name) { 'do_it' }
-    let(:config) do
-      {
-        from_states: [
-          { names: ["pending_student_completion"], roles: ['creating_user'] },
-          { names: ["pending_advisor_completion"], roles: ['advising'] }
-        ],
-        transition_to: :under_review,
-        notifications: [
-          { notification_type: 'email', name: 'Hyrax::ConfirmSubmission', to: 'creating_user', cc: 'advising' }
-        ]
-      }
-    end
-
-    before do
-      class ConfirmSubmission
-      end
-    end
-    after { Hyrax.send(:remove_const, :ConfirmSubmission) }
-    it 'exposes .generate_from_schema as a convenience method' do
-      expect_any_instance_of(described_class).to receive(:call)
-      described_class.generate_from_schema(workflow: workflow, name: action_name, config: {})
-    end
-
-    context '#call' do
-      subject { described_class.new(workflow: workflow, action_name: action_name, config: config) }
-
-      it 'will generate the various data entries (but only once)' do
-        expect do
-          subject.call
-        end.to change { Sipity::Notification.count }
-          .and change { Sipity::WorkflowAction.count }
-
-        # It can be called repeatedly without updating things
-        [:update_attribute, :update_attributes, :update_attributes!, :save, :save!, :update, :update!].each do |method_names|
-          expect_any_instance_of(ActiveRecord::Base).not_to receive(method_names)
-        end
-        subject.call
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-RSpec.describe Hyrax::Workflow::StatusListService do
-  describe "#each" do
-    let(:user) { create(:user) }
-    let(:context) { double(current_user: user, logger: double(debug: nil)) }
-    let(:service) { described_class.new(context, "workflow_state_name_ssim:initial") }
-    let!(:sipity_entity) { create(:sipity_entity) }
-    let(:document) do
-      { id: '33333',
-        has_model_ssim: ['GenericWork'],
-        actionable_workflow_roles_ssim: ["foobar-generic_work-approving", "foobar-generic_work-rejecting"],
-        workflow_state_name_ssim: ["initial"],
-        title_tesim: ['Hey dood!'] }
-    end
-    let(:ability) do
-      { id: '44444',
-        has_model_ssim: ['GenericWork'],
-        title_tesim: ['bad result'] }
-    end
-    let(:workflow_role) { instance_double(Sipity::Role, name: 'approving') }
-    let(:workflow_roles) { [instance_double(Sipity::WorkflowRole, role: workflow_role)] }
-    let(:results) { service.each.to_a }
-
-    before do
-      ActiveFedora::SolrService.add([document, ability], commit: true)
-    end
-
-    context "when user has roles" do
-      let(:template) { double('template', source_id: 'foobar') }
-      let(:workflow) do
-        instance_double(Sipity::Workflow, name: 'generic_work', permission_template: template)
-      end
-
-      before do
-        allow(Hyrax::Workflow::PermissionQuery).to receive(:scope_processing_workflow_roles_for_user_and_workflow).and_return(workflow_roles)
-        allow(Sipity::Workflow).to receive(:all).and_return([workflow])
-      end
-
-      it "returns status rows" do
-        expect(results.size).to eq 1
-        expect(results.first).to be_kind_of(SolrDocument)
-        expect(results.first.to_s).to eq 'Hey dood!'
-        expect(results.first.workflow_state).to eq 'initial'
-      end
-
-      describe '#search_solr' do
-        let(:mock_response) { { 'response' => { 'docs' => [{}, {}, {}] } } }
-
-        it 'queries Solr via HTTP POST method' do
-          allow(ActiveFedora::SolrService).to receive(:post).and_return(mock_response)
-          allow(ActiveFedora::SolrService).to receive(:get)
-          service.send(:search_solr)
-          expect(ActiveFedora::SolrService).to have_received(:post)
-          expect(ActiveFedora::SolrService).not_to have_received(:get)
-        end
-      end
-    end
-
-    context "when user doesn't have roles" do
-      before do
-        allow(Hyrax::Workflow::PermissionQuery).to receive(:scope_processing_workflow_roles_for_user_and_workflow).and_return([])
-      end
-      it "returns nothing" do
-        expect(results).to be_empty
-      end
-    end
-  end
-end