hyrax 2.0.3 → 2.1.0.beta1

data/spec/factories/collections_factory.rb

@@ -1,12 +1,66 @@
 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 { FactoryBot.create(:user) }
+      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| ["Title #{n}"] }
 
-    after(:build) do |work, evaluator|
-      work.apply_depositor_metadata(evaluator.user.user_key)
+    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]
@@ -28,4 +82,53 @@ FactoryBot.define do
       description ['collection description']
     end
   end
+
+  factory :user_collection, 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, 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| ["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/file_sets.rb

@@ -1,7 +1,7 @@
 FactoryBot.define do
   factory :file_set do
     transient do
-      user { FactoryBot.create(:user) }
+      user { create(:user) }
       content nil
     end
     after(:build) do |fs, evaluator|
@@ -30,7 +30,7 @@ FactoryBot.define do
         if evaluator.content
           Hydra::Works::UploadFileToFileSet.call(file, evaluator.content)
         end
-        FactoryBot.create(:generic_work, user: evaluator.user).members << file
+        create(:work, user: evaluator.user).members << file
       end
     end
   end

data/spec/factories/generic_works.rb

@@ -1,7 +1,7 @@
 FactoryBot.define do
   factory :work, aliases: [:generic_work, :private_generic_work], class: GenericWork do
     transient do
-      user { FactoryBot.create(:user) }
+      user { create(:user) }
       # Set to true (or a hash) if you want to create an admin set
       with_admin_set false
     end
@@ -18,6 +18,10 @@ FactoryBot.define do
       end
     end
 
+    after(:create) do |work, _evaluator|
+      work.save! if work.member_of_collections.present?
+    end
+
     title ["Test title"]
     visibility Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
 
@@ -31,51 +35,55 @@ FactoryBot.define do
       visibility Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
     end
 
+    factory :private_work do
+      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 << FactoryBot.create(:file_set, user: evaluator.user, title: ['A Contained FileSet'], label: 'filename.pdf')
+        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 << FactoryBot.create(:file_set, user: evaluator.user) } }
+      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 << FactoryBot.create(:file_set, user: evaluator.user)
-        work.ordered_member_proxies.insert_target_at(0, FactoryBot.create(:file_set, user: evaluator.user))
+        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 << FactoryBot.create(:generic_work, user: evaluator.user, title: ['A Contained Work'])
+        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 << FactoryBot.create(:generic_work, user: evaluator.user, title: ['A Contained Work'], id: "BlahBlah1")
-        work.ordered_members << FactoryBot.create(:generic_work, user: evaluator.user, title: ['Another Contained Work'], id: "BlahBlah2")
+        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 << FactoryBot.create(:file_set, user: evaluator.user, title: ['A Contained FileSet'])
+        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 << FactoryBot.create(:file_set, user: evaluator.user)
-        work.ordered_members << FactoryBot.create(:generic_work, user: evaluator.user)
+        work.ordered_members << create(:file_set, user: evaluator.user)
+        work.ordered_members << create(:work, user: evaluator.user)
       end
     end
 
@@ -90,7 +98,7 @@ FactoryBot.define do
       end
       factory :embargoed_work_with_files do
         after(:build) { |work, evaluator| work.apply_embargo(evaluator.embargo_date, evaluator.current_state, evaluator.future_state) }
-        after(:create) { |work, evaluator| 2.times { work.ordered_members << FactoryBot.create(:file_set, user: evaluator.user) } }
+        after(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, user: evaluator.user) } }
       end
     end
 
@@ -105,7 +113,7 @@ FactoryBot.define do
       end
       factory :leased_work_with_files do
         after(:build) { |work, evaluator| work.apply_lease(evaluator.lease_date, evaluator.current_state, evaluator.future_state) }
-        after(:create) { |work, evaluator| 2.times { work.ordered_members << FactoryBot.create(:file_set, user: evaluator.user) } }
+        after(:create) { |work, evaluator| 2.times { work.ordered_members << create(:file_set, user: evaluator.user) } }
       end
     end
   end
@@ -113,6 +121,6 @@ FactoryBot.define do
   # Doesn't set up any edit_users
   factory :work_without_access, class: GenericWork do
     title ['Test title']
-    depositor { FactoryBot.create(:user).user_key }
+    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/permission_templates.rb

@@ -1,23 +1,36 @@
 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 admin_set_id, I don't want to have duplication in admin_set_id
-    sequence(:admin_set_id) { |n| format("%010d", n) }
+    # 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
-        admin_set_id = permission_template.admin_set_id
+        source_id = permission_template.source_id
         admin_set =
-          if admin_set_id.present?
+          if source_id.present?
             begin
-              AdminSet.find(admin_set_id)
-            rescue
-              create(:admin_set, id: admin_set_id)
+              AdminSet.find(source_id)
+            rescue ActiveFedora::ObjectNotFoundError
+              create(:admin_set, id: source_id)
             end
           else
             create(:admin_set)
           end
-        permission_template.admin_set_id = admin_set.id
+        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
 
@@ -30,12 +43,37 @@ FactoryBot.define do
         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

data/spec/factories/users.rb

@@ -5,7 +5,7 @@ FactoryBot.define do
 
     transient do
       # Allow for custom groups when a user is instantiated.
-      # @example FactoryBot.create(:user, groups: 'avacado')
+      # @example create(:user, groups: 'avacado')
       groups []
     end
 

data/spec/factory_tests/collections_factory_spec.rb

@@ -0,0 +1,211 @@
+RSpec.describe 'Collections Factory' do # rubocop:disable RSpec/DescribeClass
+  let(:user) { build(:user, email: 'user@example.com') }
+  let(:user_mgr) { build(:user, email: 'user_mgr@example.com') }
+  let(:user_dep) { build(:user, email: 'user_dep@example.com') }
+  let(:user_vw) { build(:user, email: 'user_vw@example.com') }
+  let(:collection_type) { create(:collection_type) }
+
+  describe 'build' do
+    context 'with collection_type_settings and/or collection_type_gid' do
+      it 'will use the default User Collection type when neither is specified' do
+        col = build(:collection_lw)
+        expect(col.collection_type.title).to eq 'User Collection'
+        expect(col.collection_type.machine_id).to eq 'user_collection'
+      end
+
+      it 'uses collection type for passed in collection_type_gid when collection_type_settings is nil' do
+        col = build(:collection_lw, collection_type_gid: collection_type.gid)
+        expect(col.collection_type_gid).to eq collection_type.gid
+      end
+
+      it 'ignores collection_type_gid when collection_type_settings is set to attributes identifying settings' do
+        col = build(:collection_lw, collection_type_settings: [:not_discoverable, :not_sharable], collection_type_gid: collection_type.gid)
+        expect(col.collection_type_gid).not_to eq collection_type.gid
+      end
+
+      it 'will create a collection type when collection_type_settings is set to attributes identifying settings' do
+        expect { build(:collection_lw, collection_type_settings: [:discoverable]) }.to change { Hyrax::CollectionType.count }.by(1)
+        expect { build(:collection_lw, collection_type_settings: [:not_discoverable, :not_sharable]) }.to change { Hyrax::CollectionType.count }.by(1)
+      end
+
+      it 'will create a collection type with specified settings when collection_type_settings is set to attributes identifying settings' do
+        col = build(:collection_lw, collection_type_settings: [:not_discoverable, :not_sharable, :nestable])
+        expect(col.collection_type.discoverable?).to be false
+        expect(col.collection_type.sharable?).to be false
+        expect(col.collection_type.nestable?).to be true
+      end
+    end
+
+    context 'with_permission_template' do
+      it 'will not create a permission template or access when it is the default value of false' do
+        expect { build(:collection_lw) }.not_to change { Hyrax::PermissionTemplate.count }
+        expect { build(:collection_lw) }.not_to change { Hyrax::PermissionTemplateAccess.count }
+      end
+
+      it 'will create a permission template and one access for the creating user when set to true' do
+        expect { build(:collection_lw, with_permission_template: true) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:collection_lw, with_permission_template: true) }.to change { Hyrax::PermissionTemplateAccess.count }.by(1)
+      end
+
+      it 'will create a permission template and access for each user specified when it is set to attributes identifying access' do
+        expect { build(:collection_lw, with_permission_template: { manage_users: [user_mgr] }) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:collection_lw, with_permission_template: { manage_users: [user_mgr] }) }.to change { Hyrax::PermissionTemplateAccess.count }.by(2)
+        expect { build(:collection_lw, with_permission_template: { manage_users: [user_mgr], deposit_users: [user_dep], view_users: [user_vw] }) }
+          .to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { build(:collection_lw, with_permission_template: { manage_users: [user_mgr], deposit_users: [user_dep], view_users: [user_vw] }) }
+          .to change { Hyrax::PermissionTemplateAccess.count }.by(4)
+      end
+    end
+
+    context 'with_solr_document' do
+      it 'will not created a solr document by default' do
+        col = build(:collection_lw)
+        expect(col.id).to eq nil # no real way to confirm a solr document wasn't created if the collection doesn't have an id
+      end
+
+      context 'true' do
+        let(:col) { build(:collection_lw, with_solr_document: true) }
+
+        subject { ActiveFedora::SolrService.get("id:#{col.id}")["response"]["docs"].first }
+
+        it 'will created a solr document' do
+          expect(subject["id"]).to eq col.id
+          expect(subject["has_model_ssim"].first).to eq "Collection"
+          expect(subject["edit_access_person_ssim"]).not_to be_blank
+        end
+      end
+
+      context 'true and with_permission_template defines additional access' do
+        let(:col) do
+          build(:collection_lw, user: user,
+                                with_solr_document: true,
+                                with_permission_template: { manage_users: [user_mgr],
+                                                            deposit_users: [user_dep],
+                                                            view_users: [user_vw] })
+        end
+
+        subject { ActiveFedora::SolrService.get("id:#{col.id}")["response"]["docs"].first }
+
+        it 'will created a solr document' do
+          expect(subject["id"]).to eq col.id
+          expect(subject["has_model_ssim"].first).to eq "Collection"
+          expect(subject["edit_access_person_ssim"]).to include(user.user_key, user_mgr.user_key)
+          expect(subject["read_access_person_ssim"]).to include(user_dep.user_key, user_vw.user_key)
+        end
+      end
+    end
+
+    context 'with_nesting_attributes' do
+      let(:collection_type) { create(:collection_type) }
+      let(:blacklight_config) { CatalogController.blacklight_config }
+      let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
+      let(:current_ability) { instance_double(Ability, admin?: true) }
+      let(:scope) { double('Scope', can?: true, current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
+      let(:solr_doc) { ActiveFedora::SolrService.get("id:#{col.id}")["response"]["docs"].first }
+      let(:nesting_attributes) do
+        Hyrax::Collections::NestedCollectionQueryService::NestingAttributes.new(id: col.id, scope: scope)
+      end
+
+      context 'without additional permissions' do
+        let(:col) do
+          build(:collection_lw, id: 'Collection123',
+                                collection_type_gid: collection_type.gid,
+                                with_nesting_attributes: { ancestors: ['Parent_1'],
+                                                           parent_ids: ['Parent_1'],
+                                                           pathnames: ['Parent_1/Collection123'],
+                                                           depth: 2 })
+        end
+
+        it 'will persist a queryable solr document with the given attributes' do
+          expect(nesting_attributes.id).to eq('Collection123')
+          expect(nesting_attributes.parents).to eq(['Parent_1'])
+          expect(nesting_attributes.pathnames).to eq(['Parent_1/Collection123'])
+          expect(nesting_attributes.ancestors).to eq(['Parent_1'])
+          expect(nesting_attributes.depth).to eq(2)
+          expect(solr_doc["id"]).to eq col.id
+          expect(solr_doc["has_model_ssim"].first).to eq "Collection"
+          expect(solr_doc["edit_access_person_ssim"]).to include(col.depositor)
+        end
+      end
+
+      context ' and with_permission_template' do
+        let(:col) do
+          build(:collection_lw, id: 'Collection123',
+                                collection_type_gid: collection_type.gid,
+                                with_nesting_attributes: { ancestors: ['Parent_1'],
+                                                           parent_ids: ['Parent_1'],
+                                                           pathnames: ['Parent_1/Collection123'],
+                                                           depth: 2 },
+                                with_permission_template: { manage_users: [user_mgr],
+                                                            deposit_users: [user_dep],
+                                                            view_users: [user_vw] })
+        end
+
+        it 'will persist a queryable solr document with the given attributes' do
+          expect(nesting_attributes.id).to eq('Collection123')
+          expect(nesting_attributes.parents).to eq(['Parent_1'])
+          expect(nesting_attributes.pathnames).to eq(['Parent_1/Collection123'])
+          expect(nesting_attributes.ancestors).to eq(['Parent_1'])
+          expect(nesting_attributes.depth).to eq(2)
+          expect(solr_doc["id"]).to eq col.id
+          expect(solr_doc["has_model_ssim"].first).to eq "Collection"
+          expect(solr_doc["edit_access_person_ssim"]).to include(col.depositor, user_mgr.user_key)
+          expect(solr_doc["read_access_person_ssim"]).to include(user_dep.user_key, user_vw.user_key)
+        end
+      end
+
+      context 'and with_permission_template and with_solr_document' do
+        let(:col) do
+          build(:collection_lw, id: 'Collection123',
+                                collection_type_gid: collection_type.gid,
+                                with_nesting_attributes: { ancestors: ['Parent_1'],
+                                                           parent_ids: ['Parent_1'],
+                                                           pathnames: ['Parent_1/Collection123'],
+                                                           depth: 2 },
+                                with_permission_template: { manage_users: [user_mgr],
+                                                            deposit_users: [user_dep],
+                                                            view_users: [user_vw] },
+                                with_solr_document: true)
+        end
+
+        it 'will persist a queryable solr document with the given attributes' do
+          expect(nesting_attributes.id).to eq('Collection123')
+          expect(nesting_attributes.parents).to eq(['Parent_1'])
+          expect(nesting_attributes.pathnames).to eq(['Parent_1/Collection123'])
+          expect(nesting_attributes.ancestors).to eq(['Parent_1'])
+          expect(nesting_attributes.depth).to eq(2)
+          expect(solr_doc["id"]).to eq col.id
+          expect(solr_doc["has_model_ssim"].first).to eq "Collection"
+          expect(solr_doc["edit_access_person_ssim"]).to include(col.depositor, user_mgr.user_key)
+          expect(solr_doc["read_access_person_ssim"]).to include(user_dep.user_key, user_vw.user_key)
+        end
+      end
+    end
+  end
+
+  describe 'create' do
+    # collection_type_settings and collection_type_gid are tested by `build` and are the same for `build` and `create`
+    # with_solr_document is tested by build
+    # with_permission_template is tested by build except that the permission template is always created for `create`
+    # with_nested_attributes not supported for create
+
+    context 'with_permission_template' do
+      it 'will create a permission template and access even when it is the default value of false' do
+        expect { create(:collection_lw) }.to change { Hyrax::PermissionTemplate.count }.by(1)
+        expect { create(:collection_lw) }.to change { Hyrax::PermissionTemplateAccess.count }.by(1)
+      end
+    end
+
+    context 'when including nesting indexing', with_nested_reindexing: true do
+      # 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.
+      let(:user) { create(:user) }
+      let(:collection) { create(:collection_lw, user: user) }
+
+      it 'will authorize the creating user' do
+        expect(user.can?(:edit, collection)).to be true
+      end
+    end
+  end
+end