hyrax 5.0.0.rc2 → 5.0.0

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

data/spec/factories/generic_works.rb

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