hyrax 5.0.0.rc1 → 5.0.0.rc3

data/spec/factories/collection_types.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :collection_type, class: Hyrax::CollectionType do
+    sequence(:title) { |n| "Collection Type #{n}" }
+    sequence(:machine_id) { |n| "title_#{n}" }
+
+    description { 'Collection type with all options' }
+    nestable { true }
+    discoverable { true }
+    sharable { true }
+    brandable { true }
+    share_applies_to_new_works { true }
+    allow_multiple_membership { true }
+    require_membership { false }
+    assigns_workflow { false }
+    assigns_visibility { false }
+
+    transient do
+      creator_user { nil }
+      creator_group { nil }
+      manager_user { nil }
+      manager_group { nil }
+    end
+
+    after(:create) do |collection_type, evaluator|
+      CollectionTypeFactoryHelper.process_access(collection_type, evaluator)
+    end
+
+    trait :nestable do
+      nestable { true }
+    end
+
+    trait :not_nestable do
+      nestable { false }
+    end
+
+    trait :discoverable do
+      discoverable { true }
+    end
+
+    trait :not_discoverable do
+      discoverable { false }
+    end
+
+    trait :brandable do
+      brandable { true }
+    end
+
+    trait :not_brandable do
+      brandable { false }
+    end
+
+    trait :sharable do
+      sharable { true }
+      share_applies_to_new_works { true }
+    end
+
+    trait :sharable_no_work_permissions do
+      sharable { true }
+      share_applies_to_new_works { false }
+    end
+
+    trait :not_sharable do
+      sharable { false }
+      share_applies_to_new_works { false }
+    end
+
+    trait :allow_multiple_membership do
+      allow_multiple_membership { true }
+    end
+
+    trait :not_allow_multiple_membership do
+      allow_multiple_membership { false }
+    end
+  end
+
+  factory :user_collection_type, class: Hyrax::CollectionType do
+    initialize_with { Hyrax::CollectionType.find_or_create_default_collection_type }
+  end
+
+  factory :admin_set_collection_type, class: Hyrax::CollectionType do
+    initialize_with { Hyrax::CollectionType.find_or_create_admin_set_type }
+
+    transient do
+      creator_user { nil }
+      creator_group { nil }
+      manager_user { nil }
+      manager_group { nil }
+    end
+
+    after(:create) do |collection_type, evaluator|
+      CollectionTypeFactoryHelper.process_access(collection_type, evaluator)
+    end
+  end
+
+  class CollectionTypeFactoryHelper
+    def self.process_access(collection_type, evaluator) # rubocop:disable Metrics/MethodLength
+      if evaluator.creator_user
+        Array(evaluator.creator_user).each do |user|
+          attributes = { hyrax_collection_type_id: collection_type.id,
+                         access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS,
+                         agent_id: user,
+                         agent_type: Hyrax::CollectionTypeParticipant::USER_TYPE }
+          FactoryBot.create(:collection_type_participant, attributes)
+        end
+      end
+
+      if evaluator.creator_group
+        Array(evaluator.creator_group).each do |group|
+          attributes = { hyrax_collection_type_id: collection_type.id,
+                         access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS,
+                         agent_id: group,
+                         agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE }
+          FactoryBot.create(:collection_type_participant, attributes)
+        end
+      end
+
+      if evaluator.manager_user
+        Array(evaluator.manager_user).each do |user|
+          attributes = { hyrax_collection_type_id: collection_type.id,
+                         access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS,
+                         agent_id: user,
+                         agent_type: Hyrax::CollectionTypeParticipant::USER_TYPE }
+          FactoryBot.create(:collection_type_participant, attributes)
+        end
+      end
+
+      return unless evaluator.manager_group
+
+      Array(evaluator.manager_group).each do |group|
+        attributes = { hyrax_collection_type_id: collection_type.id,
+                       access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS,
+                       agent_id: group,
+                       agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE }
+        FactoryBot.create(:collection_type_participant, attributes)
+      end
+    end
+  end
+end

data/spec/factories/collections.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  # Tests that create a Fedora Object are very slow.  This factory lets you control which parts of the object ecosystem
+  # get built.
+  #
+  # PREFERRED: Use build whenever possible.  You can control the creation of the permission template, collection type, and
+  #            solr document by passing parameters to the build(:collection_lw) method.  That way you can build only the parts
+  #            needed for a specific test.
+  #
+  # AVOID: Do not use create unless absolutely necessary.  It will create everything including the Fedora object.
+  #
+  # @example Simple build of a collection with no additional parts created.  Lightest weight.
+  #          NOTE: A user is automatically created as the owner of the collection.
+  #   let(:collection) { build(:collection_lw) }
+  #
+  # @example Simple build of a collection with no additional parts created.  User is the owner of the collection.  Lightest weight.
+  #   let(:collection) { build(:collection_lw, user:) }
+  #
+  # @example Simple build of a collection with only solr-document.  Owner is given edit-access in solr-document. Light weight.
+  #   let(:collection) { build(:collection_lw, with_solr_document: true) }
+  #
+  # @example Simple build of a collection with only a permission template created.  Owner is set as a manager.  Light weight.
+  #   let(:collection) { build(:collection_lw, with_permission_template: true) }
+  #
+  # @example Build a collection with only a permission template created.  Permissions are set based on
+  #          attributes set for `with_permission_template`.  Middle weight.
+  #   # permissions passed thru `with_permission_template` can be any of the following in any combination
+  #   let(:permissions) { { manage_users: [user.user_key],  # multiple users can be listed
+  #                         deposit_users: [user.user_key],
+  #                         view_users: [user.user_key],
+  #                         manage_groups: [group_name],    # multiple groups can be listed
+  #                         deposit_groups: [group_name],
+  #                         view_groups: [group_name],  } }
+  #   let(:collection) { build(:collection_lw, user: , with_permission_template: permissions) }
+  #
+  # @example Build a collection with permission template and solr-document created.  Permissions are set based on
+  #          attributes set for `with_permission_template`.  Solr-document includes read/edit access defined based
+  #          on attributes passed thru `with_permission_template`.  Middle weight.
+  #   # permissions passed thru `with_permission_template` can be any of the following in any combination
+  #   let(:permissions) { { manage_users: [user.user_key],  # multiple users can be listed
+  #                         deposit_users: [user.user_key],
+  #                         view_users: [user.user_key],
+  #                         manage_groups: [group_name],    # multiple groups can be listed
+  #                         deposit_groups: [group_name],
+  #                         view_groups: [group_name],  } }
+  #   let(:collection) { build(:collection_lw, user: , with_permission_template: permissions, with_solr_document: true) }
+  #
+  # @example Build a collection generating its collection type with specific settings. Light Weight.
+  #          NOTE: Do not use this approach if you need access to the collection type in the test.
+  #          DEFAULT: If `collection_type_settings` and `collection_type` are not specified, then the default
+  #          User Collection type will be used.
+  #   # Any not specified default to ON.  At least one setting should be specified.
+  #   let(:settings) { [
+  #                      :nestable,                  # OR :not_nestable,
+  #                      :discoverable,              # OR :not_discoverable
+  #                      :brandable,                 # OR :not_brandable
+  #                      :sharable,                  # OR :not_sharable OR :sharable_no_work_permissions
+  #                      :allow_multiple_membership, # OR :not_allow_multiple_membership
+  #                    ] }
+  #   let(:collection) { build(:collection_lw, collection_type_settings: settings) }
+  #
+  # @example Build a collection using the passed in collection type.  Light Weight.
+  #          NOTE: Use this approach if you need access to the collection type in the test.
+  #   # Any not specified default to ON.  At least one setting should be specified.
+  #   let(:settings) { [
+  #                      :nestable,                  # OR :not_nestable,
+  #                      :discoverable,              # OR :not_discoverable
+  #                      :brandable,                 # OR :not_brandable
+  #                      :sharable,                  # OR :not_sharable OR :sharable_no_work_permissions
+  #                      :allow_multiple_membership, # OR :not_allow_multiple_membership
+  #                    ] }
+  #   let(:collection_type) { create(:collection_lw_type, settings) }
+  #   let(:collection) { build(:collection_lw, collection_type: collection_type) }
+
+  factory :collection_lw, class: Collection do
+    transient do
+      user { FactoryBot.create(:user) }
+
+      collection_type { nil }
+      collection_type_settings { nil }
+      with_permission_template { false }
+      with_solr_document { false }
+    end
+    sequence(:title) { |n| ["Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.collection_type_gid = evaluator.collection_type.to_global_id if evaluator.collection_type&.id.present?
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+
+      CollectionLwFactoryHelper.process_collection_type_settings(collection, evaluator)
+      CollectionLwFactoryHelper.process_with_permission_template(collection, evaluator)
+      CollectionLwFactoryHelper.process_with_solr_document(collection, evaluator)
+    end
+
+    before(:create) do |collection, evaluator|
+      # force create a permission template if it doesn't exist for the newly created collection
+      CollectionLwFactoryHelper.process_with_permission_template(collection, evaluator, true) unless evaluator.with_permission_template
+    end
+
+    after(:create) do |collection, _evaluator|
+      collection.permission_template.reset_access_controls_for(collection: collection, interpret_visibility: true)
+    end
+
+    factory :public_collection_lw, traits: [:public_lw]
+
+    factory :private_collection_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+    end
+
+    factory :institution_collection_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+    end
+
+    factory :named_collection_lw do
+      title { ['collection title'] }
+      description { ['collection description'] }
+    end
+
+    trait :public_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+    end
+
+    trait :private_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+    end
+
+    trait :institution_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+    end
+
+    trait :public_lw do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+    end
+  end
+
+  factory :user_collection_lw, class: Collection do
+    transient do
+      user { FactoryBot.create(:user) }
+      collection_type { create(:user_collection_type) }
+    end
+
+    sequence(:title) { |n| ["User Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+    end
+  end
+
+  factory :typeless_collection_lw, class: Collection do
+    # To create a pre-Hyrax 2.1.0 collection without a collection type gid...
+    #   col = build(:typeless_collection, ...)
+    #   col.save(validate: false)
+    transient do
+      user { FactoryBot.create(:user) }
+      with_permission_template { false }
+      do_save { false }
+    end
+
+    sequence(:title) { |n| ["Typeless Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+      collection.save(validate: false) if evaluator.do_save || evaluator.with_permission_template
+      if evaluator.with_permission_template
+        attributes = { source_id: collection.id }
+        attributes[:manage_users] = [evaluator.user]
+        attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
+        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: collection.id)
+      end
+    end
+  end
+
+  class CollectionLwFactoryHelper
+    # @returns array of user keys
+    def self.permission_from_template(permission_template_attributes, permission_key)
+      permissions = []
+      return permissions if permission_template_attributes.blank?
+      return permissions unless permission_template_attributes.is_a? Hash
+      return permissions unless permission_template_attributes.key?(permission_key)
+      permission_template_attributes[permission_key]
+    end
+    private_class_method :permission_from_template
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @parem [String] creator_user is the user who created the new collection
+    # @param [Boolean] include_creator, when true, adds the creator_user as a manager
+    # @returns array of user keys
+    def self.user_managers(permission_template_attributes, creator_user)
+      managers = permission_from_template(permission_template_attributes, :manage_users)
+      managers << creator_user
+      managers
+    end
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @returns array of user keys
+    def self.group_managers(permission_template_attributes)
+      permission_from_template(permission_template_attributes, :manage_groups)
+    end
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @returns array of user keys
+    def self.user_depositors(permission_template_attributes)
+      permission_from_template(permission_template_attributes, :deposit_users)
+    end
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @returns array of user keys
+    def self.group_depositors(permission_template_attributes)
+      permission_from_template(permission_template_attributes, :deposit_groups)
+    end
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @returns array of user keys
+    def self.user_viewers(permission_template_attributes)
+      permission_from_template(permission_template_attributes, :view_users)
+    end
+
+    # @param [Hash] permission_template_attributes where names identify the role and value are the user keys for that role
+    # @returns array of user keys
+    def self.group_viewers(permission_template_attributes)
+      permission_from_template(permission_template_attributes, :view_groups)
+    end
+
+    # Process the collection_type_settings transient property such that...
+    # * creates the collection type with specified settings if collection_type_settings has settings (ignores collection_type_gid)
+    # * uses passed in collection type if collection_type_gid is specified AND collection_type_settings is nil
+    # * uses default User Collection type if neither are specified
+    # @param [Collection] collection object being built/created by the factory
+    # @param [Class] evaluator holding the transient properties for the current build/creation process
+    def self.process_collection_type_settings(collection, evaluator)
+      if evaluator.collection_type_settings.present?
+        collection.collection_type = FactoryBot.create(:collection_type, *evaluator.collection_type_settings)
+      elsif collection.collection_type_gid.blank?
+        collection.collection_type = FactoryBot.create(:user_collection_type)
+      end
+    end
+
+    # Process the with_permission_template transient property such that...
+    # * a permission template is created for the collection
+    # * a permission template access is created for the collection creator
+    # * additional permission template accesses are created for each user/group identified in the attributes
+    #   of with_permission_template (created by the permission_template factory)
+    # @param [Collection] collection object being built/created by the factory
+    # @param [Class] evaluator holding the transient properties for the current build/creation process
+    # @param [Boolean] if true, force the permission template to be created
+    def self.process_with_permission_template(collection, evaluator, force = false)
+      return unless force || evaluator.with_permission_template
+      collection.id ||= FactoryBot.generate(:object_id)
+      attributes = { source_id: collection.id }
+      attributes[:manage_users] = user_managers(evaluator.with_permission_template, evaluator.user)
+      attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
+      FactoryBot.create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: collection.id)
+    end
+
+    # Process the with_solr_document transient property such that...
+    # * a solr document is created for the collection
+    # * permissions identified by with_permission_template, if any, are added to the solr fields
+    # @param [Collection] collection object being built/created by the factory
+    # @param [Class] evaluator holding the transient properties for the current build/creation process
+    def self.process_with_solr_document(collection, evaluator)
+      return unless evaluator.with_solr_document
+      Hyrax::SolrService.add(solr_document_with_permissions(collection, evaluator), commit: true)
+    end
+
+    # Return the collection's solr document with permissions added, such that...
+    # * permissions identified by with_permission_template, if any, are added to the solr fields
+    # @param [Collection] collection object being built/created by the factory
+    # @param [Class] evaluator holding the transient properties for the current build/creation process
+    # @returns the collection's solr document with permissions added
+    def self.solr_document_with_permissions(collection, evaluator)
+      collection.id ||= FactoryBot.generate(:object_id)
+      collection.edit_users = user_managers(evaluator.with_permission_template, evaluator.user)
+      collection.edit_groups = group_managers(evaluator.with_permission_template)
+      collection.read_users = user_viewers(evaluator.with_permission_template) +
+                              user_depositors(evaluator.with_permission_template)
+      collection.read_groups = group_viewers(evaluator.with_permission_template) +
+                               group_depositors(evaluator.with_permission_template)
+      collection.to_solr
+    end
+    private_class_method :solr_document_with_permissions
+  end
+end

data/spec/factories/collections_factory.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :collection do
+    # DEPRECATION: This factory is being replaced by collection_lw defined in collections.rb.  New tests should use the
+    # light weight collection factory.  DO NOT ADD tests using this factory.
+    #
+    # rubocop:disable Layout/LineLength
+    # @example let(:collection) { build(:collection, collection_type_settings: [:not_nestable, :discoverable, :sharable, :allow_multiple_membership]) }
+    # rubocop:enable Layout/LineLength
+
+    transient do
+      user { FactoryBot.create(:user) }
+      # allow defaulting to default user collection
+      collection_type_settings { nil }
+      with_permission_template { false }
+      create_access { false }
+    end
+    sequence(:title) { |n| ["Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+      if evaluator.collection_type_settings.present?
+        collection.collection_type = create(:collection_type, *evaluator.collection_type_settings)
+      elsif collection.collection_type_gid.nil?
+        collection.collection_type = create(:user_collection_type)
+      end
+    end
+
+    after(:create) do |collection, evaluator|
+      # create the permission template if it was requested
+      if evaluator.with_permission_template || evaluator.create_access
+        attributes = { source_id: collection.id }
+        attributes[:manage_users] = CollectionFactoryHelper.user_managers(evaluator.with_permission_template, evaluator.user, evaluator.create_access)
+        attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
+        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: collection.id)
+        collection.permission_template.reset_access_controls_for(collection: collection, interpret_visibility: true)
+      end
+    end
+
+    factory :public_collection, traits: [:public]
+
+    trait :public do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+    end
+
+    factory :private_collection do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+    end
+
+    factory :institution_collection do
+      visibility { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+    end
+
+    factory :named_collection do
+      title { ['collection title'] }
+      description { ['collection description'] }
+    end
+  end
+
+  factory :user_collection, class: Collection do
+    transient do
+      user { FactoryBot.create(:user) }
+      collection_type { create(:user_collection_type) }
+    end
+
+    sequence(:title) { |n| ["User Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+    end
+  end
+
+  factory :typeless_collection, class: Collection do
+    # To create a pre-Hyrax 2.1.0 collection without a collection type gid...
+    #   col = build(:typeless_collection, ...)
+    #   col.save(validate: false)
+    transient do
+      user { FactoryBot.create(:user) }
+      with_permission_template { false }
+      create_access { false }
+      do_save { false }
+    end
+
+    sequence(:title) { |n| ["Typeless Collection Title #{n}"] }
+
+    after(:build) do |collection, evaluator|
+      collection.apply_depositor_metadata(evaluator.user.user_key)
+      collection.save(validate: false) if evaluator.do_save || evaluator.with_permission_template
+      if evaluator.with_permission_template
+        attributes = { source_id: collection.id }
+        attributes[:manage_users] = [evaluator.user] if evaluator.create_access
+        attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
+        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: collection.id)
+      end
+    end
+  end
+
+  class CollectionFactoryHelper
+    def self.user_managers(permission_template_attributes, creator_user, include_creator = false)
+      managers = []
+      managers << creator_user.user_key if include_creator
+      return managers unless permission_template_attributes.respond_to?(:merge)
+      return managers unless permission_template_attributes.key?(:manage_users)
+      managers + permission_template_attributes[:manage_users]
+    end
+  end
+end

data/spec/factories/content_blocks.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :content_block do |_cb|
+  end
+end

data/spec/factories/counter_metrics.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :counter_metric, class: "Hyrax::CounterMetric" do
+    worktype { "Generic Work" }
+    resource_type { "Book" }
+    work_id { "12345678" }
+    date { Date.new(2023, 7, 17) }
+    total_item_investigations { 10 }
+    total_item_requests { 5 }
+  end
+end

data/spec/factories/featured_works.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :featured_work do |_u|
+  end
+end

data/spec/factories/file_sets.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+FactoryBot.define do
+  factory :file_set do
+    transient do
+      user { FactoryBot.create(:user) }
+      content { nil }
+    end
+    after(:build) do |fs, evaluator|
+      fs.apply_depositor_metadata evaluator.user.user_key
+    end
+
+    after(:create) do |file, evaluator|
+      Hydra::Works::UploadFileToFileSet.call(file, evaluator.content) if evaluator.content
+    end
+
+    trait :public do
+      read_groups { ["public"] }
+    end
+
+    trait :registered do
+      read_groups { ["registered"] }
+    end
+
+    trait :image do
+      content { File.open(Hyrax::Engine.root + 'spec/fixtures/world.png') }
+    end
+
+    trait :with_original_file do
+      after(:create) do |file_set, _evaluator|
+        Hydra::Works::AddFileToFileSet
+          .call(file_set, File.open(Hyrax::Engine.root + 'spec/fixtures/world.png'), :original_file)
+      end
+    end
+
+    factory :file_with_work do
+      after(:build) do |file, _evaluator|
+        file.title = ['testfile']
+      end
+      after(:create) do |file, evaluator|
+        Hydra::Works::UploadFileToFileSet.call(file, evaluator.content) if evaluator.content
+        create(:work, user: evaluator.user).members << file
+      end
+    end
+  end
+end