hyrax 5.0.0.rc2 → 5.0.0.rc3

data/spec/factories/generic_works.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :work, aliases: [:generic_work, :private_generic_work], class: 'GenericWork' do
+    transient do
+      user { FactoryBot.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.try(:member_of_collections) && work.member_of_collections.present?
+    end
+
+    title { ["Test title"] }
+
+    after(:build) do |work, evaluator|
+      work.apply_depositor_metadata(evaluator.user.user_key) if work.try(: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_image_files do
+      before(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, :image, 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/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