hyrax 2.9.6 → 3.0.0.pre.beta1

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

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

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

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe Hyrax::Workflow::WorkflowFactory do
+  describe '.create' do
+    let(:work) { create(:work, with_admin_set: { with_permission_template: true }) }
+    let(:permission_template) { Hyrax::PermissionTemplate.find_by!(source_id: work.admin_set_id) }
+    let(:workflow) { create(:workflow, active: true, permission_template: permission_template) }
+    let(:attributes) { {} }
+    let(:user) { create(:user) }
+    let(:deposit_action) { Sipity::WorkflowAction.create!(workflow: workflow, name: 'start') }
+
+    subject { described_class.create(work, attributes, user) }
+
+    it 'creates a Sipity::Entity, assign entity specific responsibility (but not to the full workflow) then runs the WorkflowActionService' do
+      expect(Hyrax::Workflow::WorkflowActionService).to receive(:run).with(
+        subject: kind_of(Hyrax::WorkflowActionInfo), action: deposit_action
+      )
+      expect do
+        expect do
+          subject
+        end.to change { Sipity::Entity.count }.by(1)
+                                              .and change { Sipity::EntitySpecificResponsibility.count }.by(1)
+      end.not_to change { Sipity::WorkflowResponsibility.count }
+    end
+  end
+end

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

@@ -0,0 +1,241 @@
+require "spec_helper"
+
+RSpec.describe Hyrax::Workflow::WorkflowImporter do
+  let(:permission_template) { create(:permission_template) }
+  let(:data) do
+    {
+      workflows: [
+        {
+          name: "ulra_submission",
+          label: "This is the label",
+          description: "This description could get really long",
+          allows_access_grant: true,
+          actions: [{
+            name: "approve",
+            transition_to: "reviewed",
+            from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
+          }]
+        }
+      ]
+    }
+  end
+  let(:validator) { double(call: true) }
+  let(:importer) { described_class.new(data: {}, permission_template: permission_template, validator: validator) }
+
+  subject { importer }
+
+  before { described_class.clear_load_errors! }
+
+  describe '#default_validator' do
+    subject { importer.send(:default_validator) }
+
+    it { is_expected.to respond_to(:call) }
+  end
+
+  describe '#default_schema' do
+    subject { importer.send(:default_schema) }
+
+    it { is_expected.to respond_to(:call) }
+  end
+
+  it 'validates the data against the schema' do
+    subject
+    expect(validator).to have_received(:call).with(data: subject.send(:data), schema: subject.send(:schema), logger: subject.send(:logger))
+  end
+
+  describe '.load_workflow_for' do
+    it 'will assocate the workflows' do
+      expect do
+        described_class.load_workflow_for(permission_template: permission_template)
+      end.to change { Sipity::Workflow.count }
+    end
+  end
+
+  describe '.generate_from_hash' do
+    it 'creates the requisite data from the configuration' do
+      number_of_workflows_created = 1
+      expect(Hyrax::Workflow::WorkflowPermissionsGenerator).to receive(:call).and_call_original
+      expect(Hyrax::Workflow::SipityActionsGenerator).to receive(:call).and_call_original
+      result = nil
+      expect do
+        result = described_class.generate_from_hash(data: data, permission_template: permission_template)
+      end.to change { Sipity::Workflow.count }.by(number_of_workflows_created).and(change { permission_template.available_workflows.count }.by(number_of_workflows_created))
+      expect(result).to match_array(kind_of(Sipity::Workflow))
+      expect(described_class.load_errors).to be_empty
+      first_workflow = result.first
+      expect(first_workflow.label).to eq "This is the label"
+      expect(first_workflow.description).to eq "This description could get really long"
+      expect(first_workflow.allows_access_grant?).to be true
+    end
+  end
+
+  describe 'data generation' do
+    let(:logger) { Logger.new(STDOUT) }
+    let(:data) { { workflows: [{ name: '', actions: [] }] } }
+    let(:importer) { described_class.new(data: data, permission_template: permission_template, logger: logger) }
+
+    describe 'with invalid data' do
+      it 'logs the output' do
+        expect(logger).to receive(:error).with(kind_of(String))
+        expect { importer }.to raise_error(RuntimeError)
+      end
+    end
+
+    describe 'with very invalid schema' do
+      let(:data) { { workflows: [{ name: '' }] } }
+
+      it 'logs the output' do
+        expect(logger).to receive(:error).with(kind_of(String))
+        expect { importer }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  context "when I load JSON twice" do
+    let!(:workflow1) { described_class.generate_from_hash(data: data, permission_template: permission_template).first }
+    let(:workflow2) { described_class.generate_from_hash(data: data, permission_template: permission_template).first }
+    let(:workflow2_errors) { described_class.load_errors }
+
+    context 'with the same data' do
+      it "workflow and workflow states do not change" do
+        workflow1
+        # If the Sipity::WorkflowState IDs or Sipity::Workflow IDs change, we are going to have a serious problem upstream
+        expect do
+          expect do
+            workflow2
+          end.not_to change { Sipity::WorkflowState.all.pluck(:id).sort }
+        end.not_to change { Sipity::Workflow.all.pluck(:id).sort }
+        expect(workflow2).to eq(workflow1)
+        expect(workflow2_errors).to be_empty
+      end
+    end
+
+    context 'with different data' do
+      let(:action_name)  { "awesome action" }
+      let(:state_name)   { "awesome state" }
+      let(:workflow2) { described_class.generate_from_hash(data: updated_data, permission_template: permission_template).first }
+      let(:updated_data) do
+        {
+          workflows: [
+            {
+              name: workflow_name,
+              label: "This is the label for the second json",
+              description: "This description could get really long",
+              actions: [{
+                name: action_name,
+                transition_to: state_name,
+                from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
+              }]
+            }
+          ]
+        }
+      end
+
+      context 'that includes a workflow_name changes' do
+        let(:workflow_name) { "awsome workflow" }
+
+        it "creates a new workflow (preserving the old)" do
+          expect(workflow2).not_to eq(workflow1)
+          expect(Sipity::Workflow.count).to eq(2)
+          expect(Sipity::WorkflowState.count).to eq(4)
+          expect(workflow2_errors).to be_empty
+        end
+      end
+
+      context "that keeps the same workflow_name name" do
+        let(:workflow_name) { "ulra_submission" }
+
+        it "preserves state names identified in actions > transition_to and actions> from_states > names hash key" do
+          expect(workflow2.label).not_to eq(workflow1.label)
+          expect(workflow2).to eq(workflow1)
+          expect(Sipity::Workflow.count).to eq(1)
+          expect(workflow2_errors).to be_empty
+          expect(Sipity::WorkflowAction.count).to eq(1)
+          expect(Sipity::WorkflowState.count).to eq(2)
+        end
+
+        context "when entities are in a state that is no longer included" do
+          let(:data) do
+            {
+              workflows: [
+                {
+                  name: "ulra_submission",
+                  label: "This is the label",
+                  description: "This description could get really long",
+                  allows_access_grant: true,
+                  actions: [{
+                    name: "approve",
+                    transition_to: "reviewed",
+                    from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
+                  }, {
+                    name: "decline",
+                    transition_to: "declined",
+                    from_states: [{ names: ['under_review'], roles: ['ulra_reviewing'] }]
+                  }]
+                }
+              ]
+            }
+          end
+          let(:workflow_state) { workflow1.reload.workflow_states.find_by(name: 'declined') }
+          let!(:entity) { Sipity::Entity.create(workflow_state: workflow_state, proxy_for_global_id: "abc123", workflow_id: workflow1.id) }
+
+          it "reports an error and does not update the WorkflowStates" do
+            expect do
+              expect do
+                expect do
+                  workflow2
+                end.not_to change { Sipity::Workflow.count }
+              end.not_to change { Sipity::WorkflowState.count }
+            end.not_to change { Sipity::WorkflowAction.count }
+            expect(workflow2_errors).to eq(["The workflow: ulra_submission has not been updated.  " \
+                                            "You are removing a state: #{workflow_state.name} with " \
+                                            "1 entity/ies.  A state may not be removed while it has " \
+                                            "active entities!"])
+          end
+        end
+      end
+    end
+  end
+
+  context 'data generation' do
+    let(:invalid_data) do
+      {
+        workflows: [
+          {
+            name: "ulra_submission",
+            label: "",
+            description: "",
+            actions: [{ name: "approve", transition_to: "reviewed", from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }] }]
+          }
+        ]
+      }
+    end
+
+    context 'with incomplete data' do
+      it 'will not load any of the data' do
+        expect do
+          expect do
+            expect do
+              expect do
+                described_class.generate_from_hash(data: invalid_data, permission_template: permission_template)
+              end.to raise_error(RuntimeError)
+            end.not_to change { Sipity::Workflow.count }
+          end.not_to change { Sipity::WorkflowAction.count }
+        end.not_to change { Sipity::WorkflowState.count }
+      end
+
+      it 'will not amend when new data is invalid' do
+        described_class.generate_from_hash(data: data, permission_template: permission_template)
+        expect do
+          expect do
+            expect do
+              expect do
+                described_class.generate_from_hash(data: invalid_data, permission_template: permission_template)
+              end.to raise_error(RuntimeError)
+            end.not_to change { Sipity::Workflow.count }
+          end.not_to change { Sipity::WorkflowAction.count }
+        end.not_to change { Sipity::WorkflowState.count }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+module Hyrax
+  module Workflow
+    RSpec.describe WorkflowPermissionsGenerator do
+      let(:workflow) { Sipity::Workflow.new(name: 'Hello') }
+      let(:workflow_permissions_configuration) do
+        [
+          { role: "work_submitting" },
+          { role: "etd_reviewing" }
+        ]
+      end
+
+      before do
+        workflow_permissions_configuration.each do |config|
+          Sipity::Role.find_or_create_by!(name: config.fetch(:role))
+        end
+      end
+
+      it 'exposes .call as a convenience method' do
+        expect_any_instance_of(described_class).to receive(:call)
+        described_class.call(workflow: workflow, workflow_permissions_configuration: workflow_permissions_configuration)
+      end
+
+      subject { described_class.new(workflow: workflow, workflow_permissions_configuration: workflow_permissions_configuration) }
+
+      it 'will create groups and assign permissions accordingly' do
+        allow_any_instance_of(PermissionGenerator).to receive(:call)
+        subject.call
+
+        # And it won't keep creating 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/workflow_schema_spec.rb

@@ -0,0 +1,86 @@
+module Hyrax
+  module Workflow
+    RSpec.describe 'WorkflowSchema' do
+      let(:valid_data) do
+        {
+          workflows: [
+            {
+              name: "valid",
+              allows_access_grant: true,
+              actions: [
+                {
+                  name: "finalize_digitization",
+                  from_states: [{ names: ["pending"], roles: ['finalizing_digitation_review'] }],
+                  transition_to: "metadata_review"
+                }, {
+                  name: "finalize_metadata",
+                  from_states: [{ names: ["metadata_review"], roles: ['finalizing_metadata_review'] }],
+                  transition_to: "final_review",
+                  notifications: [
+                    {
+                      name: notification_name, notification_type: Sipity::Notification::NOTIFICATION_TYPE_EMAIL, to: ['finalizing_metadata_review']
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      end
+
+      let(:notification_name) { 'DoTheThing' }
+
+      let(:invalid_data) do
+        {
+          workflows: [
+            {
+              actions: [
+                { name: "finalize_digitization", from_states: [{ names: ["pending"], roles: [] }], transition_to: "metadata_review" }
+              ]
+            }
+          ]
+        }
+      end
+
+      before do
+        class ::DoTheThing
+        end
+      end
+
+      after do
+        Object.send(:remove_const, :DoTheThing)
+      end
+
+      it 'validates valid data by returning an empty message' do
+        expect(WorkflowSchema.call(valid_data).messages).to be_empty
+      end
+
+      it 'reports invalid data via the returned messages' do
+        expect(WorkflowSchema.call(invalid_data).messages).not_to be_empty
+      end
+
+      describe 'notification names' do
+        context 'with an uninitialized constant' do
+          let(:notification_name) { 'FooBar' }
+
+          it 'is invalid' do
+            expect(WorkflowSchema.call(valid_data).messages).not_to be_empty
+          end
+        end
+
+        context 'within a namespace' do
+          before do
+            class DoTheThing
+            end
+          end
+          after { Hyrax::Workflow.send(:remove_const, :DoTheThing) }
+          let(:notification_name) { 'Hyrax::Workflow::DoTheThing' }
+
+          it 'returns an empty message because valid' do
+            expect(WorkflowSchema.call(valid_data).messages).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/hyrax/working_directory_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Hyrax::WorkingDirectory do
+  let(:path1) { described_class.send(:full_filename, 'abcdefghijklmnop1', 'foo.tif') }
+  let(:path2) { described_class.send(:full_filename, 'abcdefghijklmnop2', 'foo.tif') }
+
+  describe "#full_filename" do
+    it "generates unique filenames for different files" do
+      expect(path1).not_to eq(path2)
+      expect(path1).to match(/\/tmp\/uploads\/ab\/cd\/ef\/gh\/abcdefghijklmnop1\/foo.tif$/)
+      expect(path2).to match(/\/tmp\/uploads\/ab\/cd\/ef\/gh\/abcdefghijklmnop2\/foo.tif$/)
+    end
+  end
+end

data/spec/services/hyrax/works/managed_works_service_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe Hyrax::Works::ManagedWorksService, clean_repo: true do
+  let(:blacklight_config) { CatalogController.blacklight_config }
+  let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
+
+  let(:current_ability) { instance_double(Ability, admin?: true) }
+  let(:scope) { double('Scope', can?: true, current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
+
+  describe '.managed_works_count' do
+    subject { described_class.managed_works_count(scope: scope) }
+
+    let!(:work) { create(:public_work) }
+
+    it 'returns number of works that can be managed' do
+      expect(subject).to eq(1)
+    end
+  end
+end