hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/factories/generic_works.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :work, aliases: [:generic_work, :private_generic_work], class: GenericWork do
+    transient do
+      user { create(:user) }
+      # Set to true (or a hash) if you want to create an admin set
+      with_admin_set { false }
+    end
+
+    # It is reasonable to assume that a work has an admin set; However, we don't want to
+    # go through the entire rigors of creating that admin set.
+    before(:create) do |work, evaluator|
+      if evaluator.with_admin_set
+        attributes = {}
+        attributes[:id] = work.admin_set_id if work.admin_set_id.present?
+        attributes = evaluator.with_admin_set.merge(attributes) if evaluator.with_admin_set.respond_to?(:merge)
+        admin_set = create(:admin_set, attributes)
+        work.admin_set_id = admin_set.id
+      end
+    end
+
+    after(:create) do |work, _evaluator|
+      work.save! if work.member_of_collections.present?
+    end
+
+    title { ["Test title"] }
+
+    after(:build) do |work, evaluator|
+      work.apply_depositor_metadata(evaluator.user.user_key)
+    end
+
+    factory :public_generic_work, aliases: [:public_work], traits: [:public]
+
+    trait :public do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+    end
+
+    factory :invalid_generic_work do
+      title { nil }
+    end
+
+    factory :private_work do
+      # private is default
+      # visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+    end
+
+    factory :registered_generic_work do
+      read_groups { ["registered"] }
+    end
+
+    factory :work_with_one_file do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:file_set, user: evaluator.user, title: ['A Contained FileSet'], label: 'filename.pdf')
+      end
+    end
+
+    factory :work_with_files do
+      before(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, user: evaluator.user) } }
+    end
+
+    factory :work_with_ordered_files do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:file_set, user: evaluator.user)
+        work.ordered_member_proxies.insert_target_at(0, create(:file_set, user: evaluator.user))
+      end
+    end
+
+    factory :work_with_one_child do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:work, user: evaluator.user, title: ['A Contained Work'])
+      end
+    end
+
+    factory :work_with_two_children do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:work, user: evaluator.user, title: ['A Contained Work'], id: "BlahBlah1")
+        work.ordered_members << create(:work, user: evaluator.user, title: ['Another Contained Work'], id: "BlahBlah2")
+      end
+    end
+
+    factory :work_with_representative_file do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:file_set, user: evaluator.user, title: ['A Contained FileSet'])
+        work.representative_id = work.members[0].id
+      end
+    end
+
+    factory :work_with_file_and_work do
+      before(:create) do |work, evaluator|
+        work.ordered_members << create(:file_set, user: evaluator.user)
+        work.ordered_members << create(:work, user: evaluator.user)
+      end
+    end
+
+    factory :with_embargo_date do
+      # build with defaults:
+      # let(:work) { create(:embargoed_work) }
+
+      # build with specific values:
+      # let(:embargo_attributes) do
+      #   { embargo_date: Date.tomorrow.to_s,
+      #     current_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
+      #     future_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      # end
+      # let(:work) { create(:embargoed_work, with_embargo_attributes: embargo_attributes) }
+
+      transient do
+        with_embargo_attributes { false }
+        embargo_date { Date.tomorrow.to_s }
+        current_state { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+        future_state { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      end
+      factory :embargoed_work do
+        after(:build) do |work, evaluator|
+          if evaluator.with_embargo_attributes
+            work.apply_embargo(evaluator.with_embargo_attributes[:embargo_date],
+                               evaluator.with_embargo_attributes[:current_state],
+                               evaluator.with_embargo_attributes[:future_state])
+          else
+            work.apply_embargo(evaluator.embargo_date,
+                               evaluator.current_state,
+                               evaluator.future_state)
+          end
+        end
+      end
+      factory :embargoed_work_with_files do
+        after(:build) do |work, evaluator|
+          if evaluator.with_embargo_attributes
+            work.apply_embargo(evaluator.with_embargo_attributes[:embargo_date],
+                               evaluator.with_embargo_attributes[:current_state],
+                               evaluator.with_embargo_attributes[:future_state])
+          else
+            work.apply_embargo(evaluator.embargo_date,
+                               evaluator.current_state,
+                               evaluator.future_state)
+          end
+        end
+        after(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, user: evaluator.user) } }
+      end
+    end
+
+    factory :with_lease_date do
+      # build with defaults:
+      # let(:work) { create(:leased_work) }
+
+      # build with specific values:
+      # let(:lease_attributes) do
+      #   { lease_date: Date.tomorrow.to_s,
+      #     current_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+      #     future_state: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      # end
+      # let(:work) { create(:leased_work, with_lease_attributes: lease_attributes) }
+
+      transient do
+        with_lease_attributes { false }
+        lease_date { Date.tomorrow.to_s }
+        current_state { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        future_state { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+      end
+      factory :leased_work do
+        after(:build) do |work, evaluator|
+          if evaluator.with_lease_attributes
+            work.apply_lease(evaluator.with_lease_attributes[:lease_date],
+                             evaluator.with_lease_attributes[:current_state],
+                             evaluator.with_lease_attributes[:future_state])
+          else
+            work.apply_lease(evaluator.lease_date,
+                             evaluator.current_state,
+                             evaluator.future_state)
+          end
+        end
+      end
+      factory :leased_work_with_files do
+        after(:build) do |work, evaluator|
+          if evaluator.with_lease_attributes
+            work.apply_lease(evaluator.with_lease_attributes[:lease_date],
+                             evaluator.with_lease_attributes[:current_state],
+                             evaluator.with_lease_attributes[:future_state])
+          else
+            work.apply_lease(evaluator.lease_date,
+                             evaluator.current_state,
+                             evaluator.future_state)
+          end
+        end
+        after(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, user: evaluator.user) } }
+      end
+    end
+  end
+
+  # Doesn't set up any edit_users
+  factory :work_without_access, class: GenericWork do
+    title { ['Test title'] }
+    depositor { create(:user).user_key }
+  end
+end

data/spec/factories/object_id.rb

@@ -0,0 +1,6 @@
+# Defines a new sequence
+FactoryBot.define do
+  sequence :object_id do |n|
+    "object_id_#{n}"
+  end
+end

data/spec/factories/operations.rb

@@ -0,0 +1,21 @@
+FactoryBot.define do
+  factory :operation, class: Hyrax::Operation do
+    operation_type { "Test operation" }
+
+    trait :failing do
+      status { Hyrax::Operation::FAILURE }
+    end
+
+    trait :pending do
+      status { Hyrax::Operation::PENDING }
+    end
+
+    trait :successful do
+      status { Hyrax::Operation::SUCCESS }
+    end
+
+    factory :batch_create_operation, class: Hyrax::BatchCreateOperation do
+      operation_type { "Batch Create" }
+    end
+  end
+end

data/spec/factories/permission_template_accesses.rb

@@ -0,0 +1,16 @@
+FactoryBot.define do
+  factory :permission_template_access, class: Hyrax::PermissionTemplateAccess do
+    permission_template
+    trait :manage do
+      access { 'manage' }
+    end
+
+    trait :deposit do
+      access { 'deposit' }
+    end
+
+    trait :view do
+      access { 'view' }
+    end
+  end
+end

data/spec/factories/permission_templates.rb

@@ -0,0 +1,79 @@
+FactoryBot.define do
+  factory :permission_template, class: Hyrax::PermissionTemplate do
+    # Given that there is a one to one strong relation between permission_template and admin_set,
+    # with a unique index on the source_id, I don't want to have duplication in source_id
+    sequence(:source_id) { |n| format("%010d", n) }
+
+    before(:create) do |permission_template, evaluator|
+      if evaluator.with_admin_set
+        source_id = permission_template.source_id
+        admin_set =
+          if source_id.present?
+            begin
+              AdminSet.find(source_id)
+            rescue ActiveFedora::ObjectNotFoundError
+              create(:admin_set, id: source_id)
+            end
+          else
+            create(:admin_set)
+          end
+        permission_template.source_id = admin_set.id
+      elsif evaluator.with_collection
+        source_id = permission_template.source_id
+        collection =
+          if source_id.present?
+            begin
+              Collection.find(source_id)
+            rescue ActiveFedora::ObjectNotFoundError
+              create(:collection, id: source_id)
+            end
+          else
+            create(:collection)
+          end
+        permission_template.source_id = collection.id
+      end
+    end
+
+    after(:create) do |permission_template, evaluator|
+      if evaluator.with_workflows
+        Hyrax::Workflow::WorkflowImporter.load_workflow_for(permission_template: permission_template)
+        Sipity::Workflow.activate!(permission_template: permission_template, workflow_id: permission_template.available_workflows.pluck(:id).first)
+      end
+      if evaluator.with_active_workflow
+        workflow = create(:workflow, active: true, permission_template: permission_template)
+        create(:workflow_action, workflow: workflow) # Need to create a single action that can be taken
+      end
+      AccessHelper.create_access(permission_template, 'user', :manage, evaluator.manage_users) if evaluator.manage_users.present?
+      AccessHelper.create_access(permission_template, 'group', :manage, evaluator.manage_groups) if evaluator.manage_groups.present?
+      AccessHelper.create_access(permission_template, 'user', :deposit, evaluator.deposit_users) if evaluator.deposit_users.present?
+      AccessHelper.create_access(permission_template, 'group', :deposit, evaluator.deposit_groups) if evaluator.deposit_groups.present?
+      AccessHelper.create_access(permission_template, 'user', :view, evaluator.view_users) if evaluator.view_users.present?
+      AccessHelper.create_access(permission_template, 'group', :view, evaluator.view_groups) if evaluator.view_groups.present?
+    end
+
+    transient do
+      with_admin_set { false }
+      with_collection { false }
+      with_workflows { false }
+      with_active_workflow { false }
+      manage_users { nil }
+      manage_groups { nil }
+      deposit_users { nil }
+      deposit_groups { nil }
+      view_users { nil }
+      view_groups { nil }
+    end
+  end
+
+  class AccessHelper
+    def self.create_access(permission_template_id, agent_type, access, agent_ids)
+      agent_ids.each do |agent_id|
+        FactoryBot.create(:permission_template_access,
+                          access,
+                          permission_template: permission_template_id,
+                          agent_type: agent_type,
+                          agent_id: agent_id)
+      end
+    end
+  end
+end

data/spec/factories/proxy_deposit_requests.rb

@@ -0,0 +1,6 @@
+# Read about factories at https://github.com/thoughtbot/factory_bot
+
+FactoryBot.define do
+  factory :proxy_deposit_request do
+  end
+end

data/spec/factories/single_use_links.rb

@@ -0,0 +1,13 @@
+FactoryBot.define do
+  factory :single_use_link do
+    factory :show_link do
+      item_id { 'fs-id' }
+      path    { '/concerns/generic_work/1234' }
+    end
+
+    factory :download_link do
+      item_id { 'fs-id' }
+      path    { '/downloads/1234' }
+    end
+  end
+end

data/spec/factories/sipity_entities.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :sipity_entity, class: Sipity::Entity do
+    proxy_for_global_id { 'gid://internal/Mock/1' }
+    workflow { workflow_state.workflow }
+    workflow_state
+  end
+end

data/spec/factories/uploaded_files.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :uploaded_file, class: Hyrax::UploadedFile do
+    user
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,59 @@
+FactoryBot.define do
+  factory :user do
+    sequence(:email) { |n| "user#{n}@example.com" }
+    password { 'password' }
+
+    transient do
+      # Allow for custom groups when a user is instantiated.
+      # @example create(:user, groups: 'avacado')
+      groups { [] }
+    end
+
+    # TODO: Register the groups for the given user key such that we can remove the following from other specs:
+    #   `allow(::User.group_service).to receive(:byname).and_return(user.user_key => ['admin'])``
+    after(:build) do |user, evaluator|
+      # In case we have the instance but it has not been persisted
+      ::RSpec::Mocks.allow_message(user, :groups).and_return(Array.wrap(evaluator.groups))
+      # Given that we are stubbing the class, we need to allow for the original to be called
+      ::RSpec::Mocks.allow_message(user.class.group_service, :fetch_groups).and_call_original
+      # We need to ensure that each instantiation of the admin user behaves as expected.
+      # This resolves the issue of both the created object being used as well as re-finding the created object.
+      ::RSpec::Mocks.allow_message(user.class.group_service, :fetch_groups).with(user: user).and_return(Array.wrap(evaluator.groups))
+    end
+
+    factory :admin do
+      groups { ['admin'] }
+    end
+
+    factory :user_with_mail do
+      after(:create) do |user|
+        # Create examples of single file successes and failures
+        (1..10).each do |number|
+          file = MockFile.new(number.to_s, "Single File #{number}")
+          User.batch_user.send_message(user, 'File 1 could not be updated. You do not have sufficient privileges to edit it.', file.to_s, false)
+          User.batch_user.send_message(user, 'File 1 has been saved', file.to_s, false)
+        end
+
+        # Create examples of mulitple file successes and failures
+        files = []
+        (1..50).each do |number|
+          files << MockFile.new(number.to_s, "File #{number}")
+        end
+        User.batch_user.send_message(user, 'These files could not be updated. You do not have sufficient privileges to edit them.', 'Batch upload permission denied', false)
+        User.batch_user.send_message(user, 'These files have been saved', 'Batch upload complete', false)
+      end
+    end
+  end
+
+  trait :guest do
+    guest { true }
+  end
+end
+
+class MockFile
+  attr_accessor :to_s, :id
+  def initialize(id, string)
+    self.id = id
+    self.to_s = string
+  end
+end

data/spec/factories/workflow_actions.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :workflow_action, class: Sipity::WorkflowAction do
+    workflow
+    name { 'submit' }
+  end
+end

data/spec/factories/workflow_states.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :workflow_state, class: Sipity::WorkflowState do
+    workflow
+    name { 'initial' }
+  end
+end

data/spec/factories/workflows.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :workflow, class: Sipity::Workflow do
+    sequence(:name) { |n| "generic_work-#{n}" }
+    permission_template
+  end
+end

data/spec/factory_tests/adminsets_factory_spec.rb

@@ -0,0 +1,132 @@
+RSpec.describe 'AdminSets Factory' do # rubocop:disable RSpec/DescribeClass
+  let(:user) { build(:user, email: 'user@example.com') }
+  let(:user_mgr) { build(:user, email: 'user_mgr@example.com') }
+  let(:user_dep) { build(:user, email: 'user_dep@example.com') }
+  let(:user_vw) { build(:user, email: 'user_vw@example.com') }
+
+  describe 'build' do
+    context 'with_permission_template' do
+      it 'will not create a permission template or access when it is the default value of false' do
+        expect { build(:adminset_lw) }.not_to change { Hyrax::PermissionTemplate.count }
+        expect { build(:adminset_lw) }.not_to change { Hyrax::PermissionTemplateAccess.count }
+      end
+
+      it 'will create a permission template and one access for the creating user when set to true' do
+        expect { build(:adminset_lw, with_permission_template: true) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:adminset_lw, with_permission_template: true) }.to change { Hyrax::PermissionTemplateAccess.count }.by(1)
+      end
+
+      it 'will create a permission template and access for each user specified when it is set to attributes identifying access' do
+        expect { build(:adminset_lw, with_permission_template: { manage_users: [user_mgr] }) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:adminset_lw, with_permission_template: { manage_users: [user_mgr] }) }.to change { Hyrax::PermissionTemplateAccess.count }.by(2)
+        expect { build(:adminset_lw, with_permission_template: { manage_users: [user_mgr], deposit_users: [user_dep], view_users: [user_vw] }) }
+          .to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:adminset_lw, with_permission_template: { manage_users: [user_mgr], deposit_users: [user_dep], view_users: [user_vw] }) }
+          .to change { Hyrax::PermissionTemplateAccess.count }.by(4)
+      end
+    end
+
+    context 'with_solr_document' do
+      it 'will not create a solr document by default' do
+        adminset = build(:adminset_lw)
+        expect(adminset.id).to eq nil # no real way to confirm a solr document wasn't created if the admin set doesn't have an id
+      end
+
+      context 'true' do
+        let(:adminset) { build(:adminset_lw, with_solr_document: true) }
+
+        subject { ActiveFedora::SolrService.get("id:#{adminset.id}")["response"]["docs"].first }
+
+        it 'will create a solr document' do
+          expect(subject["id"]).to eq adminset.id
+          expect(subject["has_model_ssim"].first).to eq "AdminSet"
+          expect(subject["edit_access_person_ssim"]).not_to be_blank
+        end
+      end
+
+      context 'true and with_permission_template defines additional access' do
+        let(:adminset) do
+          build(:adminset_lw, user: user,
+                              with_solr_document: true,
+                              with_permission_template: { manage_users: [user_mgr],
+                                                          deposit_users: [user_dep],
+                                                          view_users: [user_vw] })
+        end
+
+        subject { ActiveFedora::SolrService.get("id:#{adminset.id}")["response"]["docs"].first }
+
+        it 'will created a solr document' do
+          expect(subject["id"]).to eq adminset.id
+          expect(subject["has_model_ssim"].first).to eq "AdminSet"
+          expect(subject["edit_access_person_ssim"]).to include(user.user_key, user_mgr.user_key)
+          expect(subject["read_access_person_ssim"]).to include(user_dep.user_key, user_vw.user_key)
+        end
+      end
+    end
+  end
+
+  describe 'create' do
+    # with_solr_document is tested by build
+    # with_permission_template is tested by build except that the permission template is always created for `create`
+
+    context 'with_permission_template: false' do
+      it 'will create a permission template and access even when it is the default value of false' do
+        expect { create(:adminset_lw) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { create(:adminset_lw) }.to change { Hyrax::PermissionTemplateAccess.count }.by(1)
+      end
+    end
+  end
+
+  describe 'default_adminset' do
+    let(:default_adminset) { build(:default_adminset) }
+    let(:solrdoc) { ActiveFedora::SolrService.get("id:#{default_adminset.id}")["response"]["docs"].first }
+    let(:permission_template) { default_adminset.permission_template }
+
+    it 'will create the default adminset with expected metadata' do
+      expect(default_adminset.id).to eq AdminSet::DEFAULT_ID
+      expect(default_adminset.title).to eq AdminSet::DEFAULT_TITLE
+    end
+
+    it 'will create solr doc with no access' do
+      expect(solrdoc["id"]).to eq default_adminset.id
+      expect(solrdoc["has_model_ssim"].first).to eq "AdminSet"
+      expect(solrdoc["edit_access_person_ssim"].count).to eq 1 # creator automatically assigned by factory
+      expect(solrdoc["read_access_person_ssim"]).to eq nil
+      expect(solrdoc["edit_access_group_ssim"]).to include(::Ability.admin_group_name)
+      expect(solrdoc["read_access_group_ssim"]).to eq nil
+    end
+
+    it 'will create permission template with registered users as depositors' do
+      expect(permission_template.agent_ids_for(access: 'deposit', agent_type: 'group'))
+        .to include(::Ability.registered_group_name)
+      expect(permission_template.agent_ids_for(access: 'manage', agent_type: 'group'))
+        .to include(::Ability.admin_group_name)
+    end
+  end
+
+  describe 'build no_solr_grants_adminset' do
+    let(:permissions) do
+      { manage_users: [user_mgr],
+        deposit_users: [user_dep],
+        view_users: [user_vw] }
+    end
+    let(:legacy_adminset) { build(:no_solr_grants_adminset, user: user, with_permission_template: permissions) }
+    let(:solrdoc) { ActiveFedora::SolrService.get("id:#{legacy_adminset.id}")["response"]["docs"].first }
+
+    it 'will create a permission template with all access' do
+      expect { build(:no_solr_grants_adminset, user: user, with_permission_template: permissions) }
+        .to change { Hyrax::PermissionTemplate.count }.by(1)
+      expect { build(:no_solr_grants_adminset, user: user, with_permission_template: permissions) }
+        .to change { Hyrax::PermissionTemplateAccess.count }.by(4)
+    end
+
+    it 'will create solr doc with creator access only' do
+      expect(solrdoc["id"]).to eq legacy_adminset.id
+      expect(solrdoc["has_model_ssim"].first).to eq "AdminSet"
+      expect(solrdoc["edit_access_person_ssim"]).to eq [user.user_key]
+      expect(solrdoc["read_access_person_ssim"]).to eq nil
+      expect(solrdoc["edit_access_group_ssim"]).to eq nil
+      expect(solrdoc["read_access_group_ssim"]).to eq nil
+    end
+  end
+end