hyrax 2.0.3 → 2.1.0.beta1

data/spec/controllers/hyrax/fixity_checks_controller_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Hyrax::FixityChecksController do
         #   { file_id => [{ "checked_uri" => "...4-4d71-83ba-1bc52a5e4300/fcr:versions/version1", "passed" => true },
         #                 { "checked_uri" => ".../version2", "passed" => false },
         #                 ...] }
-        json_response.each do |_file_id, array_of_checks|
+        json_response.each_value do |array_of_checks|
           array_of_checks.each do |check_hash|
             expect(check_hash.keys).to include("file_set_id", "file_id", "checked_uri", "passed", "expected_result", "created_at")
             expect(check_hash["passed"]).to be_in([true, false])

data/spec/controllers/hyrax/generic_works_controller_spec.rb

@@ -26,6 +26,24 @@ RSpec.describe Hyrax::GenericWorksController do
     end
   end
 
+  describe 'integration test for depositor of a suppressed documents without a workflow role' do
+    let(:work) do
+      create(:work, :public, state: Vocab::FedoraResourceStatus.inactive, user: user)
+    end
+
+    before do
+      create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s)
+    end
+
+    it 'renders without the unauthorized message' do
+      get :show, params: { id: work.id }
+      expect(response.code).to eq '200'
+      expect(response).to render_template(:show)
+      expect(assigns[:presenter]).to be_instance_of Hyrax::GenericWorkPresenter
+      expect(flash[:notice]).to be_nil
+    end
+  end
+
   describe '#show' do
     before do
       create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s)
@@ -184,7 +202,7 @@ RSpec.describe Hyrax::GenericWorksController do
         expect(assigns[:form].depositor).to eq user.user_key
         expect(assigns[:curation_concern]).to be_kind_of GenericWork
         expect(assigns[:curation_concern].depositor).to eq user.user_key
-        expect(response).to render_template("layouts/dashboard")
+        expect(response).to render_template("layouts/hyrax/dashboard")
       end
     end
   end
@@ -208,10 +226,22 @@ RSpec.describe Hyrax::GenericWorksController do
     end
 
     context 'when create fails' do
+      let(:work) { create(:work) }
       let(:create_status) { false }
+      let(:errors) { double }
+      let(:messages) { double }
+      let(:error_messages) { ['Error: foo bar'] }
+
+      before do
+        allow(controller).to receive(:curation_concern).and_return(work)
+        allow(work).to receive(:errors).and_return(errors)
+        allow(errors).to receive(:messages).and_return(messages)
+        allow(messages).to receive(:[]).with(:collections).and_return(error_messages)
+      end
 
       it 'draws the form again' do
         post :create, params: { generic_work: { title: ['a title'] } }
+        expect(flash[:error]).to eq error_messages.to_sentence
         expect(response.status).to eq 422
         expect(assigns[:form]).to be_kind_of Hyrax::GenericWorkForm
         expect(response).to render_template 'new'
@@ -330,7 +360,7 @@ RSpec.describe Hyrax::GenericWorksController do
         get :edit, params: { id: work }
         expect(response).to be_success
         expect(assigns[:form]).to be_kind_of Hyrax::GenericWorkForm
-        expect(response).to render_template("layouts/dashboard")
+        expect(response).to render_template("layouts/hyrax/dashboard")
       end
     end
 
@@ -431,9 +461,21 @@ RSpec.describe Hyrax::GenericWorksController do
 
       describe 'update failed' do
         let(:actor) { double(update: false) }
+        let(:work) { create(:work) }
+        let(:errors) { double }
+        let(:messages) { double }
+        let(:error_messages) { ['Error: foo bar'] }
+
+        before do
+          allow(controller).to receive(:curation_concern).and_return(work)
+          allow(work).to receive(:errors).and_return(errors)
+          allow(errors).to receive(:messages).and_return(messages)
+          allow(messages).to receive(:[]).with(:collections).and_return(error_messages)
+        end
 
         it 'renders the form' do
           patch :update, params: { id: work, generic_work: {} }
+          expect(flash[:error]).to eq error_messages.to_sentence
           expect(assigns[:form]).to be_kind_of Hyrax::GenericWorkForm
           expect(response).to render_template('edit')
         end
@@ -524,4 +566,24 @@ RSpec.describe Hyrax::GenericWorksController do
       expect(assigns(:form)).not_to be_blank
     end
   end
+
+  describe '#manifest' do
+    let(:work) { create(:work_with_one_file, user: user) }
+    let(:file_set) { work.ordered_members.to_a.first }
+    let(:manifest_factory) { double(to_h: { test: 'manifest' }) }
+
+    before do
+      Hydra::Works::AddFileToFileSet.call(file_set,
+                                          File.open(fixture_path + '/world.png'),
+                                          :original_file)
+      allow(IIIFManifest::ManifestFactory).to receive(:new)
+        .with(Hyrax::WorkShowPresenter)
+        .and_return(manifest_factory)
+    end
+
+    it "produces a manifest" do
+      get :manifest, params: { id: work, format: :json }
+      expect(response.body).to eq "{\"test\":\"manifest\"}"
+    end
+  end
 end

data/spec/controllers/hyrax/homepage_controller_spec.rb

@@ -98,7 +98,7 @@ RSpec.describe Hyrax::HomepageController, type: :controller do
     end
 
     context "with featured works" do
-      let!(:my_work) { FactoryBot.create(:work, user: user) }
+      let!(:my_work) { create(:work, user: user) }
 
       before do
         FeaturedWork.create!(work_id: my_work.id)

data/spec/controllers/hyrax/my/works_controller_spec.rb

@@ -11,16 +11,19 @@ RSpec.describe Hyrax::My::WorksController, type: :controller do
 
     before do
       allow(Hyrax::CollectionsService).to receive(:new).and_return(collection_service)
+      allow(Hyrax::Works::ManagedWorksService).to receive(:managed_works_count).and_return(1)
     end
+
     it "shows search results and breadcrumbs" do
       expect(controller).to receive(:search_results).with(ActionController::Parameters).and_return([response, doc_list])
       expect(controller).to receive(:add_breadcrumb).with('Home', root_path(locale: 'en'))
       expect(controller).to receive(:add_breadcrumb).with('Administration', dashboard_path(locale: 'en'))
       expect(controller).to receive(:add_breadcrumb).with('Works', my_works_path(locale: 'en'))
-      expect(collection_service).to receive(:search_results).with(:edit).and_return([my_collection])
+      expect(collection_service).to receive(:search_results).with(:deposit).and_return([my_collection])
       get :index, params: { per_page: 2 }
       expect(assigns[:document_list].length).to eq 2
       expect(assigns[:user_collections]).to contain_exactly(my_collection)
+      expect(assigns[:managed_works_count]).to eq 1
     end
   end
 

data/spec/controllers/hyrax/pages_controller_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Hyrax::PagesController, type: :controller do
-  let(:user) { FactoryBot.create(:user) }
+  let(:user) { create(:user) }
 
   before do
     sign_in user
@@ -34,16 +34,16 @@ RSpec.describe Hyrax::PagesController, type: :controller do
   end
   context 'when editing pages' do
     let!(:about_page) do
-      FactoryBot.create(:content_block, name: 'about_page')
+      create(:content_block, name: 'about_page')
     end
     let!(:help_page) do
-      FactoryBot.create(:content_block, name: 'help_page')
+      create(:content_block, name: 'help_page')
     end
     let!(:agreement_page) do
-      FactoryBot.create(:content_block, name: 'agreement_page')
+      create(:content_block, name: 'agreement_page')
     end
     let!(:terms_page) do
-      FactoryBot.create(:content_block, name: 'terms_page')
+      create(:content_block, name: 'terms_page')
     end
 
     context 'with an unprivileged user' do
@@ -63,7 +63,7 @@ RSpec.describe Hyrax::PagesController, type: :controller do
     end
 
     context 'with an administrator' do
-      let(:user) { FactoryBot.create(:admin) }
+      let(:user) { create(:admin) }
 
       describe "GET #edit" do
         it "renders breadcrumbs and dashboard layout" do
@@ -73,35 +73,35 @@ RSpec.describe Hyrax::PagesController, type: :controller do
           expect(controller).to receive(:add_breadcrumb).with('Pages', edit_pages_path)
           get :edit
           expect(response).to have_http_status(200)
-          expect(response).to render_template('layouts/dashboard')
+          expect(response).to render_template('layouts/hyrax/dashboard')
         end
       end
 
       describe "PATCH #update" do
         it "updates the about page" do
           patch :update, params: { id: about_page.id, content_block: { about: 'This is a new page about us!' } }
-          expect(response).to redirect_to(edit_pages_path)
+          expect(response).to redirect_to("#{edit_pages_path}#about")
           expect(flash[:notice]).to include 'Pages updated'
           expect(ContentBlock.for(:about).value).to eq "This is a new page about us!"
         end
 
         it "updates the help page" do
           patch :update, params: { id: help_page.id, content_block: { help: 'This page will provide more of the help you need.' } }
-          expect(response).to redirect_to(edit_pages_path)
+          expect(response).to redirect_to("#{edit_pages_path}#help")
           expect(flash[:notice]).to include 'Pages updated'
           expect(ContentBlock.for(:help).value).to eq 'This page will provide more of the help you need.'
         end
 
         it "updates the agreement page" do
           patch :update, params: { id: agreement_page.id, content_block: { agreement: 'Here is the deposit agreement' } }
-          expect(response).to redirect_to(edit_pages_path)
+          expect(response).to redirect_to("#{edit_pages_path}#agreement")
           expect(flash[:notice]).to include 'Pages updated'
           expect(ContentBlock.for(:agreement).value).to eq 'Here is the deposit agreement'
         end
 
         it "updates the terms page" do
           patch :update, params: { id: terms_page.id, content_block: { terms: 'Terms of Use are good' } }
-          expect(response).to redirect_to(edit_pages_path)
+          expect(response).to redirect_to("#{edit_pages_path}#terms")
           expect(flash[:notice]).to include 'Pages updated'
           expect(ContentBlock.for(:terms).value).to eq 'Terms of Use are good'
         end

data/spec/controllers/hyrax/users_controller_spec.rb

@@ -81,7 +81,7 @@ RSpec.describe Hyrax::UsersController, type: :controller do
       end
 
       it "uses the base query" do
-        u3 = FactoryBot.create(:user)
+        u3 = create(:user)
         allow(controller).to receive(:base_query).and_return(["email == \"#{u3.email}\""])
         get :index
         expect(assigns[:users]).to include(u3)

data/spec/controllers/hyrax/workflow_actions_controller_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Hyrax::WorkflowActionsController, type: :controller do
-  let(:user) { FactoryBot.create(:user) }
+  let(:user) { create(:user) }
   let(:generic_work) { stub_model(GenericWork, id: '123') }
   let(:form) { instance_double(Hyrax::Forms::WorkflowActionForm) }
 

data/spec/conversions/power_converters/polymorphic_type_spec.rb

@@ -1,13 +1,13 @@
 require "spec_helper"
 
-RSpec.describe 'PowerConverter', no_clean: true do
+RSpec.describe 'PowerConverter' do
   describe '#convert_to_polymorphic_type' do
     it 'will convert an object that responds to #to_polymorphic_type' do
       object = double(to_polymorphic_type: :symbol)
       expect(PowerConverter.convert_to_polymorphic_type(object)).to eq(:symbol)
     end
     it 'will convert an ActiveRecord::Base object' do
-      user = FactoryBot.build(:user)
+      user = build(:user)
       expect(PowerConverter.convert_to_polymorphic_type(user)).to eq(user.class)
     end
     it 'will convert an object that responds to #base_class' do

data/spec/conversions/power_converters/sipity_agent_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-RSpec.describe 'PowerConverter', no_clean: true do
+RSpec.describe 'PowerConverter' do
   context '#convert_to_sipity_agent' do
     it 'will convert a Sipity::Agent' do
       object = Sipity::Agent.new

data/spec/conversions/power_converters/sipity_role_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'PowerConverter', no_clean: true do
+RSpec.describe 'PowerConverter' do
   context 'role' do
     it "converts Sipity::Role" do
       object = Sipity::Role.new

data/spec/conversions/power_converters/sipity_workflow_state_spec.rb

@@ -1,4 +1,4 @@
-RSpec.describe 'PowerConverter', no_clean: true do
+RSpec.describe 'PowerConverter' do
   context 'sipity_workflow_state' do
     let(:workflow_state) { Sipity::WorkflowState.new(id: 1, name: 'hello') }
     let(:workflow) { create(:workflow) }

data/spec/factories/admin_sets.rb

@@ -9,11 +9,11 @@ FactoryBot.define do
     # This way, we can go ahead
     after(:create) do |admin_set, evaluator|
       if evaluator.with_permission_template
-        attributes = { admin_set_id: admin_set.id }
+        attributes = { source_id: admin_set.id }
         attributes = evaluator.with_permission_template.merge(attributes) if evaluator.with_permission_template.respond_to?(:merge)
-        # There is a unique constraint on permission_templates.admin_set_id; I don't want to
+        # There is a unique constraint on permission_templates.source_id; I don't want to
         # create a permission template if one already exists for this admin_set
-        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(admin_set_id: admin_set.id)
+        create(:permission_template, attributes) unless Hyrax::PermissionTemplate.find_by(source_id: admin_set.id)
       end
     end
 

data/spec/factories/collection_branding_infos.rb

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

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

@@ -0,0 +1,104 @@
+FactoryBot.define do
+  factory :collection_type, class: Hyrax::CollectionType do
+    sequence(:title) { |n| "Title #{n}" }
+    sequence(:machine_id) { |n| "title_#{n}" }
+
+    description 'Collection type with all options'
+    nestable true
+    discoverable true
+    sharable 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 :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

@@ -0,0 +1,323 @@
+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
+  #                      :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
+  #                      :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| ["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| ["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| ["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