curation_concerns 1.6.3 → 1.7.0.beta1

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

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+module CurationConcerns
+  module Workflow
+    RSpec.describe PermissionQuery, slow_test: true, no_clean: 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
+      before { CurationConcerns::Workflow::WorkflowImporter.new(data: workflow_config).call }
+      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) { Sipity::Workflow.first }
+
+      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 '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_attribute(
+            :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_attribute(
+            :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', no_clean: true 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) }
+          subject { described_class.scope_processing_agents_for(user: user) }
+          it 'will equal [kind_of(Sipity::Agent)]' do
+            is_expected.to eq([PowerConverter.convert_to_sipity_agent(user),
+                               PowerConverter.convert_to_sipity_agent(Group.new('registered'))])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/services/curation_concerns/workflow/remove_depositor_permissions_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe CurationConcerns::Workflow::RemoveDepositorPermissions do
+  let(:work) { create(:work) }
+  let(:entity) { instance_double(Sipity::Entity, id: 9999, proxy_for: work) }
+  let(:user) { User.new }
+
+  describe ".call" do
+    subject do
+      described_class.call(entity: entity,
+                           comment: "A pleasant read",
+                           user: user)
+    end
+
+    it "strips edit access " do
+      subject
+      expect(work).to be_valid
+      expect(work.edit_users).to eq []
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module CurationConcerns
+  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: ["start", "potpie"] }
+        ]
+      end
+
+      it 'exposes .call as a convenience method' do
+        expect_any_instance_of(described_class).to receive(:call)
+        described_class.call(workflow: workflow, actions_configuration: actions_configuration)
+      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/curation_concerns/workflow/state_machine_generator_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module CurationConcerns
+  RSpec.describe Workflow::StateMachineGenerator, :no_clean do
+    let(:workflow) { Sipity::Workflow.create!(name: 'hello') }
+    let(:action_name) { 'do_it' }
+    before do
+      class ConfirmSubmission
+      end
+    end
+    after { CurationConcerns.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
+
+    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: 'CurationConcerns::ConfirmSubmission', to: 'creating_user', cc: 'advising' }
+        ]
+      }
+    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).to_not receive(method_names)
+        end
+        subject.call
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe CurationConcerns::Workflow::StatusListService do
+  describe "#each" do
+    let(:user) { create(:user) }
+    let(:service) { described_class.new(user) }
+    let(:document) { { id: '33333',
+                       has_model_ssim: ['GenericWork'],
+                       actionable_workflow_roles_ssim: ["generic_work-approving", "generic_work-rejecting"],
+                       workflow_state_name_ssim: ["initial"],
+                       title_tesim: ['Hey dood!'] } }
+    let(:ability) { { id: '44444',
+                      has_model_ssim: ['GenericWork'],
+                      title_tesim: ['bad result'] } }
+    let(:workflow_role) { instance_double(Sipity::Role, name: 'approving') }
+    let(:workflow_roles) { [instance_double(Sipity::WorkflowRole, role: workflow_role)] }
+    before do
+      create(:sipity_entity)
+      ActiveFedora::SolrService.add([document, ability], commit: true)
+    end
+
+    let(:results) { service.each.to_a }
+
+    context "when user has roles" do
+      before do
+        allow(CurationConcerns::Workflow::PermissionQuery).to receive(:scope_processing_workflow_roles_for_user_and_workflow).and_return(workflow_roles)
+      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
+    end
+
+    context "when user doesn't have roles" do
+      before do
+        allow(CurationConcerns::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/curation_concerns/workflow/workflow_importer_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+RSpec.describe CurationConcerns::Workflow::WorkflowImporter do
+  let(:path) { double(read: json) }
+  let(:json) do
+    doc = <<-HERE
+    {
+      "workflows": [
+        {
+          "name": "ulra_submission",
+          "label": "This is the label",
+          "description": "This description could get really long",
+          "actions": [{
+            "name": "approve",
+            "transition_to": "reviewed",
+            "from_states": [{ "names": ["under_review"], "roles": ["ulra_reviewing"] }]
+          }]
+        }
+      ]
+    }
+    HERE
+    doc.strip
+  end
+  let(:validator) { double(call: true) }
+
+  subject { described_class.new(data: {}, validator: validator) }
+
+  its(:default_validator) { is_expected.to respond_to(:call) }
+  its(:default_schema) { is_expected.to respond_to(:call) }
+
+  it 'validates the data against the schema' do
+    subject
+    expect(validator).to have_received(:call).with(data: subject.send(:data), schema: subject.send(:schema))
+  end
+
+  context 'data generation' do
+    let(:path) { Rails.root.join('config/workflows/default_workflow.json').to_s }
+    it 'creates the requisite data from the configuration' do
+      expect(CurationConcerns::Workflow::WorkflowPermissionsGenerator).to receive(:call).and_call_original
+      expect(CurationConcerns::Workflow::SipityActionsGenerator).to receive(:call).and_call_original
+      result = nil
+      expect do
+        result = described_class.generate_from_json_file(path: path)
+      end.to change { Sipity::Workflow.count }.by(1)
+      expect(result).to match_array(kind_of(Sipity::Workflow))
+      expect(result.first.label).to eq "Default workflow"
+      expect(result.first.description).to eq "A single submission step, default workflow"
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+module CurationConcerns
+  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).to_not receive(method_names)
+        end
+        subject.call
+      end
+    end
+  end
+end

data/spec/services/curation_concerns/workflow/workflow_schema_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module CurationConcerns
+  module Workflow
+    RSpec.describe 'WorkflowSchema', no_clean: true do
+      let(:valid_data) do
+        {
+          workflows: [
+            {
+              name: "valid",
+              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 { CurationConcerns::Workflow.send(:remove_const, :DoTheThing) }
+          let(:notification_name) { 'CurationConcerns::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/sources/curation_concerns/resource_statistics_source_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe CurationConcerns::ResourceStatisticsSource do
+  subject { described_class.new }
+  describe "#open_concerns_count" do
+    it "returns the number of open concerns" do
+      create :private_generic_work
+      expect(subject.open_concerns_count).to eq(0)
+    end
+
+    context "when I have concerns" do
+      before do
+        create :public_generic_work
+      end
+      it "returns the number of open concerns" do
+        expect(subject.open_concerns_count).to eq(1)
+      end
+    end
+  end
+
+  describe "#authenticated_concerns_count" do
+    context "when I have concerns" do
+      before do
+        create :authenticated_generic_work
+      end
+      it "returns the number of open concerns" do
+        expect(subject.authenticated_concerns_count).to eq(1)
+      end
+    end
+  end
+
+  describe "#restricted_concerns_count" do
+    context "when I have concerns" do
+      before do
+        create :authenticated_generic_work
+        create :generic_work
+        create :generic_work, read_groups: ['foo']
+      end
+      it "returns the number of open concerns" do
+        expect(subject.restricted_concerns_count).to eq(2)
+      end
+    end
+  end
+
+  describe "embargoes" do
+    before do
+      create :embargoed_work, embargo_date: embargo_date, current_state: current_state, future_state: future_state
+      create :public_generic_work
+      create :authenticated_generic_work
+      create :private_generic_work
+    end
+
+    describe "#active_embargo_now_authenticated_concerns_count" do
+      before do
+        create :embargoed_work, embargo_date: Date.yesterday.to_s, current_state: current_state, future_state: future_state
+      end
+      let(:embargo_date) { Date.tomorrow.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      it "returns the number of embargo concerns" do
+        expect(subject.active_embargo_now_authenticated_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#active_embargo_now_restricted_concerns_count" do
+      let(:embargo_date) { Date.tomorrow.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      it "returns the number of embargo concerns" do
+        expect(subject.active_embargo_now_restricted_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#expired_embargo_now_authenticated_concerns_count" do
+      let(:embargo_date) { Date.yesterday.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      it "returns the number of embargo concerns" do
+        expect(subject.expired_embargo_now_authenticated_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#expired_embargo_now_open_concerns_count" do
+      let(:embargo_date) { Date.yesterday.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      it "returns the number of embargo concerns" do
+        expect(subject.expired_embargo_now_open_concerns_count).to eq(1)
+      end
+    end
+  end
+
+  describe "leases" do
+    before do
+      create :leased_work, lease_date: lease_date, current_state: current_state, future_state: future_state
+      create :public_generic_work
+      create :authenticated_generic_work
+      create :private_generic_work
+    end
+
+    describe "#active_lease_now_authenticated_concerns_count" do
+      let(:lease_date) { Date.tomorrow.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      it "returns the number of lease concerns" do
+        expect(subject.active_lease_now_authenticated_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#active_lease_now_open_concerns_count" do
+      let(:lease_date) { Date.tomorrow.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      it "returns the number of lease concerns" do
+        expect(subject.active_lease_now_open_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#expired_lease_now_authenticated_concerns_count" do
+      let(:lease_date) { Date.yesterday.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      it "returns the number of lease concerns" do
+        expect(subject.expired_lease_now_authenticated_concerns_count).to eq(1)
+      end
+    end
+
+    describe "#expired_lease_now_restricted_concerns_count" do
+      let(:lease_date) { Date.yesterday.to_s }
+      let(:current_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      let(:future_state) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      it "returns the number of lease concerns" do
+        expect(subject.expired_lease_now_restricted_concerns_count).to eq(1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ require 'devise'
 require 'mida'
 
 require 'rspec/matchers'
+require 'shoulda/matchers'
 require 'equivalent-xml/rspec_matchers'
 require 'rspec/its'
 require 'rspec/rails'
@@ -70,9 +71,15 @@ RSpec.configure do |config|
     unless example.metadata[:type] == :view || example.metadata[:no_clean]
       ActiveFedora::Cleaner.clean!
     end
+
+    # This is a speedup for workflow specs.  If we don't have this, it will import the
+    # full workflow configuration files from config/workflows/*
+    FactoryGirl.create(:workflow_action) if example.metadata[:workflow]
   end
 
   config.include FactoryGirl::Syntax::Methods
+  config.include Shoulda::Matchers::Independent
+
   if defined? Devise::Test::ControllerHelpers
     config.include Devise::Test::ControllerHelpers, type: :controller
     config.include Devise::Test::ControllerHelpers, type: :view
@@ -82,6 +89,7 @@ RSpec.configure do |config|
   end
 
   config.include TestViewHelpers, type: :view
+  config.include Capybara::DSL, type: :view
 
   config.include Warden::Test::Helpers, type: :feature
   config.after(:each, type: :feature) { Warden.test_reset! }
@@ -98,7 +106,6 @@ RSpec.configure do |config|
   config.include ::Rails.application.routes.url_helpers
 
   config.include Rails.application.routes.url_helpers, type: :routing
-  config.include Capybara::DSL
   config.include InputSupport, type: :input
   config.include Capybara::RSpecMatchers, type: :input
   config.infer_spec_type_from_file_location!