hyrax 5.0.0.rc2 → 5.0.0

data/spec/factories/hyrax_collection.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+##
+# Use this factory for generic Hyrax/HydraWorks Collections in valkyrie.
+#
+# This factory creates a Valkyrized collection set; by default a Hyrax::PcdmCollection
+#
+# Why the antics around the class?  Because of the Hyrax needs and potential downstream
+# applciation needs.
+#
+# Downstream applications might implement a different collection class and the downstream
+# application might leverage other Hyrax factories that create a `:hyrax_collection`
+FactoryBot.define do
+  factory :hyrax_collection, class: (Hyrax.config.collection_class < Valkyrie::Resource ? Hyrax.config.collection_class : 'CollectionResource'), aliases: [:collection_resource] do
+    sequence(:title) { |n| ["The Tove Jansson Collection #{n}"] }
+    collection_type_gid { Hyrax::CollectionType.find_or_create_default_collection_type.to_global_id.to_s }
+
+    transient do
+      with_permission_template { true }
+      collection_type { nil }
+      with_index { true }
+      user { FactoryBot.create(:user) }
+      edit_groups { [] }
+      edit_users { [] }
+      read_groups { [] }
+      read_users { [] }
+      members { nil }
+      access_grants { [] }
+    end
+
+    after(:build) do |collection, evaluator|
+      collection.depositor ||= evaluator.user.user_key
+      collection.collection_type_gid = evaluator.collection_type.to_global_id.to_s if evaluator.collection_type
+    end
+
+    after(:create) do |collection, evaluator|
+      if evaluator.members.present?
+        evaluator.members.map do |member|
+          member.member_of_collection_ids += [collection.id]
+          member = Hyrax.persister.save(resource: member)
+          Hyrax.index_adapter.save(resource: member) if evaluator.with_index
+        end
+      end
+      if evaluator.with_permission_template
+        Hyrax::Collections::PermissionsCreateService.create_default(collection: collection,
+                                                                    creating_user: evaluator.user,
+                                                                    grants: evaluator.access_grants)
+        collection.permission_manager.edit_groups = collection.permission_manager.edit_groups.to_a +
+                                                    evaluator.edit_groups
+        collection.permission_manager.edit_users = collection.permission_manager.edit_users.to_a +
+                                                   evaluator.edit_users
+        collection.permission_manager.read_groups = collection.permission_manager.read_groups.to_a +
+                                                    evaluator.read_groups
+        collection.permission_manager.read_users = collection.permission_manager.read_users.to_a +
+                                                   evaluator.read_users
+        collection.permission_manager.acl.save
+      end
+      Hyrax.index_adapter.save(resource: collection) if evaluator.with_index
+    end
+
+    trait :public do
+      read_groups { ['public'] }
+    end
+
+    trait :with_member_works do
+      transient do
+        members { [valkyrie_create(:hyrax_work), valkyrie_create(:hyrax_work)] }
+      end
+    end
+
+    trait :with_member_collections do
+      transient do
+        members { [valkyrie_create(:hyrax_collection), valkyrie_create(:hyrax_collection)] }
+      end
+    end
+
+    trait :as_collection_member do
+      member_of_collection_ids { [valkyrie_create(:hyrax_collection).id] }
+    end
+
+    trait :as_member_of_multiple_collections do
+      member_of_collection_ids do
+        [valkyrie_create(:hyrax_collection).id,
+         valkyrie_create(:hyrax_collection).id,
+         valkyrie_create(:hyrax_collection).id]
+      end
+    end
+
+    factory :pcdm_collection, class: 'Hyrax::PcdmCollection' do
+    end
+  end
+end

data/spec/factories/hyrax_default_admin_set.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :stored_default_admin_set_id, class: Hyrax::DefaultAdministrativeSet do
+    id { 1 }
+    default_admin_set_id { Hyrax::AdminSetCreateService::DEFAULT_ID }
+  end
+end

data/spec/factories/hyrax_embargo.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :hyrax_embargo, class: "Hyrax::Embargo" do
+    embargo_release_date      { (Time.zone.today + 10).to_datetime }
+    visibility_after_embargo  { 'open' }
+    visibility_during_embargo { 'authenticated' }
+
+    to_create do |instance|
+      saved_instance = Valkyrie.config.metadata_adapter.persister.save(resource: instance)
+      instance.id = saved_instance.id
+      saved_instance
+    end
+
+    trait :expired do
+      embargo_release_date { (Time.zone.today - 1).to_datetime }
+    end
+  end
+end

data/spec/factories/hyrax_file_metadata.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+##
+# Use this factory for FileMetadata for Files in valkyrie.
+FactoryBot.define do
+  factory :hyrax_file_metadata, class: 'Hyrax::FileMetadata', aliases: [:file_metadata] do
+    transient do
+      use { nil }
+      visibility_setting { nil }
+    end
+
+    after(:build) do |file_metadata, evaluator|
+      if evaluator.visibility_setting
+        Hyrax::VisibilityWriter
+          .new(resource: file_metadata)
+          .assign_access_for(visibility: evaluator.visibility_setting)
+      end
+      file_metadata.pcdm_use = Hyrax::FileMetadata::Use.uri_for(use: evaluator.use) if evaluator.use
+    end
+
+    after(:create) do |file_metadata, evaluator|
+      if evaluator.visibility_setting
+        writer = Hyrax::VisibilityWriter.new(resource: file_metadata)
+        writer.assign_access_for(visibility: evaluator.visibility_setting)
+        writer.permission_manager.acl.save
+      end
+    end
+
+    trait :public do
+      transient do
+        visibility_setting { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      end
+    end
+
+    trait :original_file do
+      use { Hyrax::FileMetadata::Use.uri_for(use: :original_file) }
+    end
+
+    trait :thumbnail do
+      use { Hyrax::FileMetadata::Use.uri_for(use: :thumbnail_file) }
+    end
+
+    trait :extracted_text do
+      use { Hyrax::FileMetadata::Use.uri_for(use: :extracted_file) }
+    end
+
+    trait :service_file do
+      use { Hyrax::FileMetadata::Use.uri_for(use: :service_file) }
+    end
+
+    trait :image do
+      mime_type { 'image/png' }
+    end
+
+    trait :audio_file do
+      mime_type { 'audio/x-wave' }
+    end
+
+    trait :video_file do
+      mime_type { 'video/mp4' }
+    end
+
+    trait :with_file do
+      transient do
+        file { FactoryBot.create(:uploaded_file, file: File.open(Hyrax::Engine.root + 'spec/fixtures/world.png')) }
+        file_set { FactoryBot.valkyrie_create(:hyrax_file_set) }
+        user { FactoryBot.create(:user) }
+      end
+
+      after(:build) do |file_metadata, evaluator|
+        file_metadata.label = evaluator.file.uploader.filename
+        file_metadata.mime_type = evaluator.file.uploader.content_type if file_metadata.mime_type == Hyrax::FileMetadata::GENERIC_MIME_TYPE
+        file_metadata.original_filename = evaluator.file.uploader.filename
+        file_metadata.recorded_size = evaluator.file.uploader.size
+        file_metadata.file_set_id = evaluator.file_set.id
+      end
+
+      before(:create) do |file_metadata, evaluator|
+        saved = Hyrax.storage_adapter.upload(resource: evaluator.file_set,
+                                             file: evaluator.file.uploader.file,
+                                             original_filename: evaluator.file.uploader.filename)
+        file_metadata.file_identifier = saved.id
+      end
+
+      after(:create) do |file_metadata, evaluator|
+        Hyrax::ValkyrieUpload.new.add_file_to_file_set(file_set: evaluator.file_set,
+                                                       file_metadata: file_metadata,
+                                                       user: evaluator.user)
+      end
+    end
+  end
+end

data/spec/factories/hyrax_file_set.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :hyrax_file_set, class: 'Hyrax::FileSet' do
+    transient do
+      files              { nil }
+      original_file      { nil }
+      extracted_text     { nil }
+      thumbnail          { nil }
+      visibility_setting { nil }
+      edit_users         { [] }
+      edit_groups        { [] }
+      read_users         { [] }
+      read_groups        { [] }
+      with_index         { true }
+    end
+
+    after(:build) do |file_set, evaluator|
+      if evaluator.visibility_setting
+        Hyrax::VisibilityWriter
+          .new(resource: file_set)
+          .assign_access_for(visibility: evaluator.visibility_setting)
+      end
+      file_set.file_ids = evaluator.files.map(&:id) if evaluator.files
+
+      file_set.permission_manager.edit_groups = file_set.permission_manager.edit_groups.to_a + evaluator.edit_groups
+      file_set.permission_manager.edit_users  = file_set.permission_manager.edit_users.to_a + evaluator.edit_users
+      file_set.permission_manager.read_users  = file_set.permission_manager.read_users.to_a + evaluator.read_users
+      file_set.permission_manager.read_groups = file_set.permission_manager.read_groups.to_a + evaluator.read_groups
+    end
+
+    after(:create) do |file_set, evaluator|
+      if evaluator.visibility_setting
+        writer = Hyrax::VisibilityWriter.new(resource: file_set)
+        writer.assign_access_for(visibility: evaluator.visibility_setting)
+        writer.permission_manager.acl.save
+      end
+
+      file_set.permission_manager.edit_groups = file_set.permission_manager.edit_groups.to_a + evaluator.edit_groups
+      file_set.permission_manager.edit_users  = file_set.permission_manager.edit_users.to_a + evaluator.edit_users
+      file_set.permission_manager.read_users  = file_set.permission_manager.read_users.to_a + evaluator.read_users
+      file_set.permission_manager.read_groups = file_set.permission_manager.read_groups.to_a + evaluator.read_groups
+
+      file_set.permission_manager.acl.save
+
+      Hyrax.index_adapter.save(resource: file_set) if evaluator.with_index
+    end
+
+    trait :under_embargo do
+      association :embargo, factory: :hyrax_embargo
+
+      after(:create) do |fs, _e|
+        Hyrax::EmbargoManager.new(resource: fs).apply
+        fs.permission_manager.acl.save
+      end
+    end
+
+    trait :with_expired_enforced_embargo do
+      after(:build) do |fs, _evaluator|
+        fs.embargo = FactoryBot.valkyrie_create(:hyrax_embargo, :expired)
+      end
+
+      after(:create) do |fs, _evaluator|
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_return(10.days.ago)
+        Hyrax::EmbargoManager.new(resource: fs).apply
+        fs.permission_manager.acl.save
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_call_original
+      end
+    end
+
+    trait :under_lease do
+      association :lease, factory: :hyrax_lease
+
+      after(:create) do |fs, _e|
+        Hyrax::LeaseManager.new(resource: fs).apply
+        fs.permission_manager.acl.save
+      end
+    end
+
+    trait :with_expired_enforced_lease do
+      after(:build) do |fs, _evaluator|
+        fs.lease = FactoryBot.valkyrie_create(:hyrax_lease, :expired)
+      end
+
+      after(:create) do |fs, _evaluator|
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_return(10.days.ago)
+        Hyrax::LeaseManager.new(resource: fs).apply
+        fs.permission_manager.acl.save
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_call_original
+      end
+    end
+
+    trait :public do
+      transient do
+        visibility_setting { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      end
+    end
+
+    trait :authenticated do
+      transient do
+        visibility_setting { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      end
+    end
+
+    trait :with_files do
+      transient do
+        ios { [File.open(Hyrax::Engine.root + 'spec/fixtures/image.png'), File.open(Hyrax::Engine.root + 'spec/fixtures/Example.ogg')] }
+
+        after(:create) do |file_set, evaluator|
+          evaluator.ios.each do |file|
+            filename = File.basename(file.path).to_s
+            Hyrax::ValkyrieUpload.file(filename: filename, file_set: file_set, io: file)
+          end
+        end
+      end
+    end
+
+    trait :in_work do
+      transient do
+        work { build(:hyrax_work) }
+      end
+
+      after(:create) do |file_set, evaluator|
+        evaluator.work.member_ids += [file_set.id]
+        Hyrax.persister.save(resource: evaluator.work)
+      end
+    end
+  end
+end

data/spec/factories/hyrax_lease.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :hyrax_lease, class: "Hyrax::Lease" do
+    lease_expiration_date   { (Time.zone.today + 10).to_datetime }
+    visibility_after_lease  { 'authenticated' }
+    visibility_during_lease { 'open' }
+
+    to_create do |instance|
+      saved_instance = Valkyrie.config.metadata_adapter.persister.save(resource: instance)
+      instance.id = saved_instance.id
+      saved_instance
+    end
+
+    trait :expired do
+      lease_expiration_date { (Time.zone.today - 2).to_datetime }
+    end
+  end
+end

data/spec/factories/hyrax_resource.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+##
+# Use for generic Resources, with Hyrax assumptions.
+FactoryBot.define do
+  factory :hyrax_resource, class: "Hyrax::Resource" do
+    trait :under_embargo do
+      embargo_id { FactoryBot.create(:hyrax_embargo).id }
+    end
+
+    trait :under_lease do
+      lease_id { FactoryBot.create(:hyrax_lease).id }
+    end
+  end
+end

data/spec/factories/hyrax_work.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+##
+# Use this factory for generic Hyrax/HydraWorks Works in valkyrie.
+FactoryBot.define do
+  factory :hyrax_work, class: 'Hyrax::Test::SimpleWork' do
+    trait :under_embargo do
+      association :embargo, factory: :hyrax_embargo
+
+      after(:create) do |work, _e|
+        Hyrax::EmbargoManager.new(resource: work).apply
+        work.permission_manager.acl.save
+      end
+    end
+
+    trait :with_expired_enforced_embargo do
+      after(:build) do |work, _evaluator|
+        work.embargo = FactoryBot.valkyrie_create(:hyrax_embargo, :expired)
+      end
+
+      after(:create) do |work, _evaluator|
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_return(10.days.ago)
+        Hyrax::EmbargoManager.new(resource: work).apply
+        work.permission_manager.acl.save
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_call_original
+      end
+    end
+
+    trait :under_lease do
+      association :lease, factory: :hyrax_lease
+
+      after(:create) do |work, _e|
+        Hyrax::LeaseManager.new(resource: work).apply
+        work.permission_manager.acl.save
+      end
+    end
+
+    trait :with_expired_enforced_lease do
+      after(:build) do |work, _evaluator|
+        work.lease = FactoryBot.valkyrie_create(:hyrax_lease, :expired)
+      end
+
+      after(:create) do |work, _evaluator|
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_return(10.days.ago)
+        Hyrax::LeaseManager.new(resource: work).apply
+        work.permission_manager.acl.save
+        allow(Hyrax::TimeService).to receive(:time_in_utc).and_call_original
+      end
+    end
+
+    transient do
+      edit_users         { [] }
+      edit_groups        { [] }
+      read_users         { [] }
+      read_groups        { [] }
+      members            { nil }
+      visibility_setting { nil }
+      with_index         { true }
+      uploaded_files { [] }
+    end
+
+    after(:build) do |work, evaluator|
+      if evaluator.visibility_setting
+        Hyrax::VisibilityWriter
+          .new(resource: work)
+          .assign_access_for(visibility: evaluator.visibility_setting)
+      end
+
+      work.permission_manager.edit_groups = work.permission_manager.edit_groups.to_a + evaluator.edit_groups
+      work.permission_manager.edit_users  = work.permission_manager.edit_users.to_a + evaluator.edit_users
+      work.permission_manager.read_users  = work.permission_manager.read_users.to_a + evaluator.read_users
+      work.permission_manager.read_groups = work.permission_manager.read_groups.to_a + evaluator.read_groups
+
+      work.member_ids = evaluator.members.compact.map(&:id) if evaluator.members
+    end
+
+    after(:create) do |work, evaluator|
+      if evaluator.visibility_setting
+        Hyrax::VisibilityWriter
+          .new(resource: work)
+          .assign_access_for(visibility: evaluator.visibility_setting)
+      end
+      work.permission_manager.edit_groups = work.permission_manager.edit_groups.to_a + evaluator.edit_groups
+      work.permission_manager.edit_users  = work.permission_manager.edit_users.to_a + evaluator.edit_users
+      work.permission_manager.read_users  = work.permission_manager.read_users.to_a + evaluator.read_users
+      work.permission_manager.read_groups = work.permission_manager.read_groups.to_a + evaluator.read_groups
+
+      # these are both no-ops if an active embargo/lease isn't present
+      Hyrax::EmbargoManager.new(resource: work).apply
+      Hyrax::LeaseManager.new(resource: work).apply
+
+      work.permission_manager.acl.save
+
+      # This has to happen after permissions for permissions to propagate.
+      if evaluator.uploaded_files.present?
+        allow(Hyrax.config.characterization_service).to receive(:run).and_return(true)
+        perform_enqueued_jobs(only: ValkyrieIngestJob) do
+          Hyrax::WorkUploadsHandler.new(work: Hyrax.query_service.find_by(id: work.id)).add(files: evaluator.uploaded_files).attach
+        end
+        # I'm not sure why, but Wings required this reload.
+        work.member_ids = Hyrax.query_service.find_by(id: work.id).member_ids
+      end
+
+      Hyrax.index_adapter.save(resource: Hyrax.query_service.find_by(id: work.id)) if evaluator.with_index
+    end
+
+    trait :public do
+      transient do
+        visibility_setting { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+      end
+    end
+
+    trait :with_admin_set do
+      transient do
+        admin_set { valkyrie_create(:hyrax_admin_set) }
+      end
+
+      after(:build) do |work, evaluator|
+        work.admin_set_id = evaluator.admin_set&.id
+      end
+    end
+
+    trait :with_default_admin_set do
+      admin_set_id { Hyrax::EnsureWellFormedAdminSetService.call }
+    end
+
+    trait :with_member_works do
+      transient do
+        members do
+          # If you set a depositor on the containing work, propogate that into these members
+          additional_attributes = {}
+          additional_attributes[:depositor] = depositor if depositor
+          [valkyrie_create(:hyrax_work, additional_attributes), valkyrie_create(:hyrax_work, additional_attributes)]
+        end
+      end
+    end
+
+    trait :with_file_and_work do
+      transient do
+        members do
+          # If you set a depositor on the containing work, propogate that into these members
+          additional_attributes = {}
+          additional_attributes[:depositor] = depositor if depositor
+          [valkyrie_create(:hyrax_file_set, additional_attributes), valkyrie_create(:hyrax_work, additional_attributes)]
+        end
+      end
+    end
+
+    trait :with_one_file_set do
+      transient do
+        members do
+          # If you set a depositor on the containing work, propogate that into this member
+          additional_attributes = {}
+          additional_attributes[:depositor] = depositor if depositor
+          [valkyrie_create(:hyrax_file_set, additional_attributes)]
+        end
+      end
+    end
+
+    trait :with_member_file_sets do
+      transient do
+        members do
+          # If you set a depositor on the containing work, propogate that into these members
+          additional_attributes = {}
+          additional_attributes[:depositor] = depositor if depositor
+          [valkyrie_create(:hyrax_file_set, additional_attributes), valkyrie_create(:hyrax_file_set, additional_attributes)]
+        end
+      end
+    end
+
+    trait :with_thumbnail do
+      thumbnail_id do
+        file_set = members.find(&:file_set?) ||
+                   valkyrie_create(:hyrax_file_set)
+        file_set.id
+      end
+    end
+
+    trait :with_representative do
+      representative_id do
+        file_set = members&.find(&:file_set?) ||
+                   valkyrie_create(:hyrax_file_set)
+        file_set.id
+      end
+    end
+
+    trait :with_renderings do
+      rendering_ids do
+        file_set = members.find(&:file_set?) ||
+                   valkyrie_create(:hyrax_file_set)
+        file_set.id
+      end
+    end
+
+    trait :as_collection_member do
+      member_of_collection_ids { [valkyrie_create(:hyrax_collection).id] }
+    end
+
+    trait :as_member_of_multiple_collections do
+      member_of_collection_ids do
+        [valkyrie_create(:hyrax_collection).id,
+         valkyrie_create(:hyrax_collection).id,
+         valkyrie_create(:hyrax_collection).id]
+      end
+    end
+
+    factory :monograph, class: 'Monograph' do
+      factory :comet_in_moominland do
+        title { 'Comet in Moominland' }
+        creator { 'Tove Jansson' }
+        record_info { 'An example monograph with enough metadata fill in required fields.' }
+      end
+
+      trait :with_member_works do
+        transient do
+          members { [valkyrie_create(:monograph), valkyrie_create(:monograph)] }
+        end
+      end
+    end
+  end
+end

data/spec/factories/object_id.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+# 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,22 @@
+# frozen_string_literal: true
+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.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :permission, class: "Hyrax::Permission" do
+    agent { create(:user).user_key.to_s }
+    mode  { :read }
+  end
+end

data/spec/factories/permission_template_accesses.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+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