hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/factories/collections_factory.rb

@@ -0,0 +1,134 @@
+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

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

data/spec/factories/featured_works.rb

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

data/spec/factories/file_sets.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,196 @@
+# 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

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

data/spec/factories/operations.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,79 @@
+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