hyrax 2.6.0 → 2.7.0

data/spec/factories/api_items.rb

@@ -1,91 +0,0 @@
-FactoryBot.define do
-  factory :post_item, class: Hash do
-    skip_create
-
-    token { 'mock_token' }
-
-    metadata do
-      {
-        resourceType: 'Dataset',
-        title: 'Findings from NSF Study',
-        creators: [
-          {
-            creatorType: 'author',
-            firstName: 'John',
-            lastName: 'Doe'
-          },
-          {
-            creatorType: 'seriesEditor',
-            firstName: 'Rafael',
-            lastName: 'Nadal'
-          },
-          {
-            creatorType: 'inventor',
-            name: 'Babs McGee'
-          },
-          {
-            creatorType: 'contributor',
-            name: 'Jane Doeski'
-          }
-        ],
-        description: 'This was funded by the NSF in 2013',
-        publisher: 'National Science Foundation',
-        dateCreated: '2014-11-02T14:24:64Z',
-        basedNear: 'Paris, France',
-        identifier: 'isbn:1234567890',
-        url: 'http://example.org/nsf/2013/datasets/',
-        language: 'English--New Jerseyan',
-        license: 'http://creativecommons.org/licenses/by-sa/3.0/us/',
-        tags: [
-          'datasets',
-          'nsf',
-          'stuff'
-        ]
-      }
-    end
-
-    file do
-      {
-        base64: 'YXJraXZvCg==',
-        md5: 'f03313ded2feb96f0a641b8eb098aae0',
-        filename: 'file.txt',
-        contentType: 'text/plain'
-      }
-    end
-
-    initialize_with { attributes }
-  end
-
-  factory :put_item, class: Hash, parent: :post_item do
-    metadata do
-      {
-        resourceType: 'Article',
-        title: 'THE REAL FINDINGS',
-        creators: [
-          {
-            creatorType: 'author',
-            firstName: 'John',
-            lastName: 'Doe'
-          },
-          {
-            creatorType: 'inventor',
-            name: 'Babs McGee'
-          }
-        ],
-        license: 'http://creativecommons.org/licenses/by-sa/3.0/us/',
-        tags: [
-          'datasets'
-        ]
-      }
-    end
-
-    file do
-      {
-        base64: 'IyBIRUFERVIKClRoaXMgaXMgYSBwYXJhZ3JhcGghCg==',
-        md5: '3923077bb477097b8496dbcff5fa44b3',
-        filename: 'replaced.md',
-        contentType: 'text/x-markdown'
-      }
-    end
-  end
-end

data/spec/factories/collection_branding_infos.rb

@@ -1,11 +0,0 @@
-FactoryBot.define do
-  factory :collection_branding_info do
-    collection_id { "1" }
-    role { "banner" }
-    local_path { "/fake/path/to/banner.png" }
-    alt_text { "This is the banner" }
-    target_url { "http://example.com/" }
-    height { "" }
-    width { "" }
-  end
-end

data/spec/factories/collection_type_participants.rb

@@ -1,8 +0,0 @@
-FactoryBot.define do
-  factory :collection_type_participant, class: Hyrax::CollectionTypeParticipant do
-    association :hyrax_collection_type, factory: :collection_type
-    sequence(:agent_id) { |n| "user#{n}@example.com" }
-    agent_type  { 'user' }
-    access      { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-  end
-end

data/spec/factories/collection_types.rb

@@ -1,113 +0,0 @@
-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|
-      if evaluator.creator_user
-        attributes = { hyrax_collection_type_id: collection_type.id,
-                       access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS,
-                       agent_id: evaluator.creator_user,
-                       agent_type: Hyrax::CollectionTypeParticipant::USER_TYPE }
-        create(:collection_type_participant, attributes)
-      end
-
-      if evaluator.creator_group
-        attributes = { hyrax_collection_type_id: collection_type.id,
-                       access: Hyrax::CollectionTypeParticipant::CREATE_ACCESS,
-                       agent_id: evaluator.creator_group,
-                       agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE }
-        create(:collection_type_participant, attributes)
-      end
-
-      if evaluator.manager_user
-        attributes = { hyrax_collection_type_id: collection_type.id,
-                       access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS,
-                       agent_id: evaluator.manager_user,
-                       agent_type: Hyrax::CollectionTypeParticipant::USER_TYPE }
-        create(:collection_type_participant, attributes)
-      end
-
-      if evaluator.manager_group
-        attributes = { hyrax_collection_type_id: collection_type.id,
-                       access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS,
-                       agent_id: evaluator.manager_group,
-                       agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE }
-        create(:collection_type_participant, attributes)
-      end
-    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 }
-  end
-end

data/spec/factories/collections.rb

@@ -1,325 +0,0 @@
-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_gid` 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_gid: collection_type.gid) }
-  #
-  # @example Build a collection with nesting fields set in the solr document.  Light weight.
-  #          NOTE: The property `with_nesting_attributes` is only supported for building collections.  The attributes will
-  #                be overwritten by the save process when creating a collection, thus effectively ignoring this property.
-  #   let(:collection) { build(:collection_lw, with_nesting_attributes: { ancestors: ['Parent_1'],
-  #                                                                       parent_ids: ['Parent_1'],
-  #                                                                       pathnames: ['Parent_1/Collection123'],
-  #                                                                       depth: 2 }) }
-  #
-  # @example Create a collection with everything.  Extreme heavy weight.  This is very slow and should be avoided.
-  #          NOTE: Everything gets created.
-  #          NOTE: Build options effect created collections as follows...
-  #                 * `with_permission_template` can specify user/group permissions.  A permission template is always created.
-  #                 * `collection_type_settings` can specify to create a collection type with specific settings
-  #                 * `with_solr_document` is ignored.  A solr document is always created.
-  #                 * `with_nested_attributes` is ignored.
-  #          NOTE: Additional process is required for testing nested collections with Fedora objects.  See next example.
-  #   let(:collection) { create(:collection_lw) }
-  #
-  # @example Create collections for use with nested collection index testing.
-  #          NOTE: For light weight nested collection testing using solr documents only, see `with_nested_attributes` above
-  #          NOTE: Full indexed nested collections with solr documents and Fedora objects are created by...
-  #                 * creating multiple collections (expensive)
-  #                 * nesting them and saving - causing reindex of the Fedora objects (expensive)
-  #                For tests of nesting functionality requiring the Fedora object and reindexing, in the test itself
-  #                include `:with_nested_reindexing`
-  #    it "returns the collection and its members", :with_nested_reindexing do
-
-  factory :collection_lw, class: Collection do
-    transient do
-      user { create(:user) }
-
-      collection_type_settings { nil }
-      with_permission_template { false }
-      with_nesting_attributes { nil }
-      with_solr_document { false }
-    end
-    sequence(:title) { |n| ["Collection Title #{n}"] }
-
-    after(:build) do |collection, evaluator|
-      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)
-      CollectionLwFactoryHelper.process_with_nesting_attributes(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.reset_access_controls!
-    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 { create(:user) }
-    end
-
-    sequence(:title) { |n| ["User Collection Title #{n}"] }
-
-    after(:build) do |collection, evaluator|
-      collection.apply_depositor_metadata(evaluator.user.user_key)
-      collection_type = create(:user_collection_type)
-      collection.collection_type_gid = collection_type.gid
-    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 { 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 || RSpec.current_example.metadata[:with_nested_reindexing]
-      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_nesting_attributes transient property such that...
-    # * adds nesting related solr-document fields for ancestors, parent_ids, pathnames, and depth
-    # @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_nesting_attributes(collection, evaluator)
-      return unless evaluator.with_nesting_attributes.present? && collection.nestable?
-      Hyrax::Adapters::NestingIndexAdapter.add_nesting_attributes(
-        solr_doc: solr_document_with_permissions(collection, evaluator),
-        ancestors: evaluator.with_nesting_attributes[:ancestors],
-        parent_ids: evaluator.with_nesting_attributes[:parent_ids],
-        pathnames: evaluator.with_nesting_attributes[:pathnames],
-        depth: evaluator.with_nesting_attributes[:depth]
-      )
-    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
-      return if evaluator.with_nesting_attributes.present? && collection.nestable? # will create the solr document there instead
-      ActiveFedora::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