hyrax 2.6.0 → 2.7.0

data/spec/factories/collections_factory.rb

@@ -1,134 +0,0 @@
-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 Metrics/LineLength
-    # @example let(:collection) { build(:collection, collection_type_settings: [:not_nestable, :discoverable, :sharable, :allow_multiple_membership], with_nesting_attributes: {ancestors: [], parent_ids: [], pathnames: [], depth: 1}) }
-    # rubocop:enable Metrics/LineLength
-
-    # Regarding testing nested collections:
-    # To get the nested collection solr fields in the solr document for query purposes there are two options:
-    # => 1) use create(:collection) and add "with_nested_reindexing: true" to the spec will force the collection to be
-    #       created and run through the entire indexing.
-    #    => when you need a permission template AND nesting fields in the solr_document
-    #    => certain ability tests (:discover, for example) require the permission template be created
-    # => 2) use build(:collection) and add with_nesting_attributes: {ancestors: [], parent_ids: [], pathnames: [], depth: 1}
-    #       to the build the collection and create a solr document using the given nesting attributes
-    #    => this can be used to speed up the specs when a made-up solr document is adequate and no permission template is required
-
-    transient do
-      user { create(:user) }
-      # allow defaulting to default user collection
-      collection_type_settings { nil }
-      with_permission_template { false }
-      create_access { false }
-      with_nesting_attributes { nil }
-    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
-
-      # if requested, create a solr document and add the nesting fields into it
-      # when a nestable collection is built. This reduces the need to use
-      # create and :with_nested_indexing for nested collection testing
-      if evaluator.with_nesting_attributes.present? && collection.nestable?
-        Hyrax::Adapters::NestingIndexAdapter.add_nesting_attributes(
-          solr_doc: evaluator.to_solr,
-          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
-    end
-
-    after(:create) do |collection, evaluator|
-      # create the permission template if it was requested, OR if nested reindexing is included (so we can apply the user's
-      # permissions).  Nested indexing requires that the user's permissions be saved on the Fedora object... if simply in
-      # local memory, they are lost when the adapter pulls the object from Fedora to reindex.
-      if evaluator.with_permission_template || evaluator.create_access || RSpec.current_example.metadata[:with_nested_reindexing]
-        attributes = { source_id: collection.id }
-        attributes[:manage_users] = CollectionFactoryHelper.user_managers(evaluator.with_permission_template, evaluator.user,
-                                                                          (evaluator.create_access || RSpec.current_example.metadata[:with_nested_reindexing]))
-        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.reset_access_controls!
-      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 { 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, 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 }
-      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

@@ -1,4 +0,0 @@
-FactoryBot.define do
-  factory :content_block do |_cb|
-  end
-end

data/spec/factories/featured_works.rb

@@ -1,4 +0,0 @@
-FactoryBot.define do
-  factory :featured_work do |_u|
-  end
-end

data/spec/factories/file_sets.rb

@@ -1,33 +0,0 @@
-FactoryBot.define do
-  factory :file_set do
-    transient do
-      user { 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
-
-    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

data/spec/factories/generic_works.rb

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

data/spec/factories/object_id.rb

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

data/spec/factories/operations.rb

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

data/spec/factories/permission_template_accesses.rb

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

data/spec/factories/permission_templates.rb

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