hyrax 2.6.0 → 2.7.0

data/spec/services/hyrax/collection_types/permissions_service_spec.rb

@@ -1,297 +0,0 @@
-RSpec.describe Hyrax::CollectionTypes::PermissionsService do
-  let(:user_cg) { create(:user, groups: 'create_group') }
-  let(:user_mg) { create(:user, groups: 'manage_group') }
-  let(:user_cu) { create(:user) }
-  let(:user_mu) { create(:user) }
-  let(:user_other) { create(:user) }
-  let(:user_admin) { create(:user, groups: 'admin') }
-
-  let!(:user_collection_type) { create(:user_collection_type) }
-  let!(:admin_set_collection_type) { create(:admin_set_collection_type) }
-  let!(:collection_type) { create(:collection_type, creator_user: user_cu, creator_group: 'create_group', manager_user: user_mu, manager_group: 'manage_group') }
-
-  describe '.collection_types_for_user' do # Also tests .collection_type_ids_for_user which is called by .collection_types_for_user
-    let!(:ability) { ::Ability.new(user) }
-
-    before { allow(ability).to receive(:current_user).and_return(user) }
-
-    subject { described_class.collection_types_for_user(user: user, roles: access).map(&:id) }
-
-    context 'when user is a create user' do
-      let(:user) { user_cu }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [] }
-      end
-    end
-
-    context 'when user is in create group' do
-      let(:user) { user_cg }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [] }
-      end
-    end
-
-    context 'when user is a manage user' do
-      let(:user) { user_mu }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [user_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id] }
-      end
-    end
-
-    context 'when user is in manage group' do
-      let(:user) { user_mg }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [user_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id] }
-      end
-    end
-
-    context 'when user is an admin' do
-      let(:user) { user_admin }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id, user_collection_type.id, admin_set_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [collection_type.id, user_collection_type.id, admin_set_collection_type.id] }
-      end
-    end
-
-    context 'when user with no access' do
-      let(:user) { user_other }
-
-      context 'and create access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::CREATE_ACCESS }
-
-        it { is_expected.to match_array [user_collection_type.id] }
-      end
-
-      context 'and manage access is queried' do
-        let(:access) { Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }
-
-        it { is_expected.to match_array [] }
-      end
-    end
-  end
-
-  describe '.can_create_any_collection_type?' do
-    let!(:ability) { ::Ability.new(user) }
-
-    before do
-      allow(ability).to receive(:current_user).and_return(user)
-    end
-
-    subject { described_class.can_create_any_collection_type?(user: user) }
-
-    context 'when user is a create user' do
-      let(:user) { user_cu }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user is in create group' do
-      let(:user) { user_cg }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user is a manage user' do
-      let(:user) { user_mu }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user is in manage group' do
-      let(:user) { user_mg }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user is an admin' do
-      let(:user) { user_admin }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user with no access' do
-      let(:user) { user_other }
-
-      # TODO: Fails for now becauser User Collection type is always created and it allows every logged in user to create one.
-      # Would require additional work to remove or change the User Collection participants so there are 0 collection types the
-      # user can create.
-      xit { is_expected.to be false }
-    end
-  end
-
-  describe '.can_create_admin_set?' do
-    let!(:ability) { ::Ability.new(user) }
-
-    before { allow(ability).to receive(:current_user).and_return(user) }
-
-    subject { described_class.can_create_admin_set_collection_type?(user: user) }
-
-    context 'when user is a create user' do
-      let(:user) { user_cu }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when user is in create group' do
-      let(:user) { user_cg }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when user is a manage user' do
-      let(:user) { user_mu }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when user is in manage group' do
-      let(:user) { user_mg }
-
-      it { is_expected.to be false }
-    end
-
-    context 'when user is an admin' do
-      let(:user) { user_admin }
-
-      it { is_expected.to be true }
-    end
-
-    context 'when user with no access' do
-      let(:user) { user_other }
-
-      it { is_expected.to be false }
-    end
-  end
-
-  describe '.can_create_collection_types' do
-    let!(:ability) { ::Ability.new(user) }
-
-    before { allow(ability).to receive(:current_user).and_return(user) }
-
-    subject { described_class.can_create_collection_types(user: user).map(&:id) }
-
-    context 'when user is a create user' do
-      let(:user) { user_cu }
-
-      it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-    end
-
-    context 'when user is in create group' do
-      let(:user) { user_cg }
-
-      it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-    end
-
-    context 'when user is a manage user' do
-      let(:user) { user_mu }
-
-      it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-    end
-
-    context 'when user is in manage group' do
-      let(:user) { user_mg }
-
-      it { is_expected.to match_array [collection_type.id, user_collection_type.id] }
-    end
-
-    context 'when user is an admin' do
-      let(:user) { user_admin }
-
-      it { is_expected.to match_array [collection_type.id, user_collection_type.id, admin_set_collection_type.id] }
-    end
-
-    context 'when user with no access' do
-      let(:user) { user_other }
-
-      it { is_expected.to match_array [user_collection_type.id] }
-    end
-  end
-
-  describe '.user_edit_grants_for_collection_of_type' do
-    subject { described_class.user_edit_grants_for_collection_of_type(collection_type: coltype) }
-
-    context 'for user collection type' do
-      let(:coltype) { user_collection_type }
-
-      it { is_expected.to match_array [] }
-    end
-
-    context 'for admin set collection type' do
-      let(:coltype) { admin_set_collection_type }
-
-      it { is_expected.to match_array [] }
-    end
-
-    context 'for collection type' do
-      let(:coltype) { collection_type }
-
-      it { is_expected.to match_array [user_mu.user_key] }
-    end
-  end
-
-  describe '.group_edit_grants_for_collection_of_type' do
-    subject { described_class.group_edit_grants_for_collection_of_type(collection_type: coltype) }
-
-    context 'for user collection type' do
-      let(:coltype) { user_collection_type }
-
-      it { is_expected.to match_array ['admin'] }
-    end
-
-    context 'for admin set collection type' do
-      let(:coltype) { admin_set_collection_type }
-
-      it { is_expected.to match_array ['admin'] }
-    end
-
-    context 'for collection type' do
-      let(:coltype) { collection_type }
-
-      it { is_expected.to match_array ['manage_group', 'admin'] }
-    end
-  end
-end

data/spec/services/hyrax/collections/collection_member_service_spec.rb

@@ -1,49 +0,0 @@
-RSpec.describe Hyrax::Collections::CollectionMemberService, clean_repo: true do
-  let(:blacklight_config) { CatalogController.blacklight_config }
-  let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
-  let(:current_ability) { instance_double(Ability, admin?: true) }
-  let!(:nestable_collection) { create(:public_collection_lw, collection_type_settings: [:nestable]) }
-  let(:scope) { double('Scope', current_ability: current_ability, repository: repository, blacklight_config: blacklight_config, collection: nestable_collection) }
-  let!(:subcollection) { create(:public_collection_lw, member_of_collections: [nestable_collection], collection_type_settings: [:nestable]) }
-  let(:builder) { described_class.new(scope: scope, collection: nestable_collection, params: { "id" => nestable_collection.id.to_s }) }
-
-  let!(:work1) { create(:generic_work, member_of_collections: [nestable_collection]) }
-  let!(:work2) { create(:generic_work) }
-  let!(:work3) { create(:generic_work, member_of_collections: [nestable_collection]) }
-
-  describe '#available_member_subcollections' do
-    let(:subject) { builder.available_member_subcollections }
-    let(:ids) { subject.response[:docs].map { |col| col[:id] } }
-
-    it 'returns the members that are collections' do
-      expect(ids).to include(subcollection.id)
-      expect(ids).not_to include(work1.id)
-      expect(ids).not_to include(work3.id)
-      expect(ids).not_to include(work2.id)
-    end
-  end
-
-  describe '#available_member_works' do
-    let(:subject) { builder.available_member_works }
-    let(:ids) { subject.response[:docs].map { |col| col[:id] } }
-
-    it 'returns the members that are collections' do
-      expect(ids).to include(work1.id)
-      expect(ids).to include(work3.id)
-      expect(ids).not_to include(work2.id)
-      expect(ids).not_to include(subcollection.id)
-    end
-  end
-
-  describe '#available_member_work_ids' do
-    let(:subject) { builder.available_member_work_ids }
-    let(:ids) { subject.response[:docs].map { |col| col[:id] } }
-
-    it 'returns the members ids that are works' do
-      expect(ids).to include(work1.id)
-      expect(ids).to include(work3.id)
-      expect(ids).not_to include(work2.id)
-      expect(ids).not_to include(subcollection.id)
-    end
-  end
-end

data/spec/services/hyrax/collections/managed_collections_service_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Hyrax::Collections::ManagedCollectionsService, clean_repo: true do
-  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) }
-
-  describe '.managed_collections_count' do
-    subject { described_class.managed_collections_count(scope: scope) }
-
-    let!(:collection) { create(:public_collection) }
-
-    it 'returns number of collections that can be managed' do
-      expect(subject).to eq(1)
-    end
-  end
-end

data/spec/services/hyrax/collections/migration_service_spec.rb

@@ -1,467 +0,0 @@
-RSpec.describe Hyrax::Collections::MigrationService, clean_repo: true do
-  let(:user) { create(:user) }
-  let(:editor1) { create(:user) }
-  let(:editor2) { create(:user) }
-  let(:reader1) { create(:user) }
-  let(:reader2) { create(:user) }
-  let(:manager1) { create(:user) }
-  let(:manager2) { create(:user) }
-  let(:depositor1) { create(:user) }
-  let(:depositor2) { create(:user) }
-  let(:viewer1) { create(:user) }
-  let(:viewer2) { create(:user) }
-  let(:default_gid) { create(:user_collection_type).gid }
-
-  describe ".migrate_all_collections" do
-    context 'when legacy collections are found (e.g. collections created before Hyrax 2.1.0)' do
-      let!(:col_none) { build(:typeless_collection, user: user, edit_users: [user.user_key], do_save: true) }
-      let!(:col_vu) { build(:typeless_collection, user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key], do_save: true) }
-      let!(:col_vg) { build(:typeless_collection, user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'], do_save: true) }
-      let!(:col_mu) { build(:typeless_collection, user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key], do_save: true) }
-      let!(:col_mg) { build(:typeless_collection, user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'], do_save: true) }
-
-      it 'sets gid and adds permissions' do # rubocop:disable RSpec/ExampleLength
-        Collection.all.each do |col|
-          expect(col.collection_type_gid).to be_nil
-          expect { Hyrax::PermissionTemplate.find_by!(source_id: col.id) }.to raise_error ActiveRecord::RecordNotFound
-        end
-
-        Hyrax::Collections::MigrationService.migrate_all_collections
-
-        Collection.all.each do |col|
-          expect(col.collection_type_gid).to eq default_gid
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-          expect(pt_id).not_to be_nil
-          expect_access(pt_id, 'user', :manage, col.edit_users)
-          expect_access(pt_id, 'group', :manage, col.edit_groups)
-          expect_access(pt_id, 'user', :deposit, [])
-          expect_access(pt_id, 'group', :deposit, [])
-          expect_access(pt_id, 'user', :view, col.read_users)
-          expect_access(pt_id, 'group', :view, col.read_groups)
-        end
-      end
-    end
-
-    context 'when newer collections are found (e.g. collections created at or after Hyrax 2.1.0)' do
-      let!(:collection) do
-        build(:collection_lw,
-              id: 'col_newer', user: user,
-              with_permission_template: { manage_users: [manager1.user_key] },
-              with_solr_document: true)
-      end
-      let!(:permission_template) { collection.permission_template }
-      let!(:collection_type_gid) { collection.collection_type_gid }
-      let!(:edit_users) { collection.edit_users }
-
-      before do
-        allow(Collection).to receive(:all).and_return([collection])
-      end
-
-      it "doesn't change the collection" do
-        expect(collection.collection_type_gid).to eq collection_type_gid
-        expect(Hyrax::PermissionTemplate.find_by!(source_id: collection.id).id).to eq permission_template.id
-        expect_access(permission_template.id, 'user', :manage, [user.user_key, manager1.user_key])
-
-        Hyrax::Collections::MigrationService.migrate_all_collections
-
-        expect(collection.collection_type_gid).to eq collection_type_gid
-        expect(Hyrax::PermissionTemplate.find_by!(source_id: collection.id).id).to eq permission_template.id
-        expect_access(permission_template.id, 'user', :manage, [user.user_key, manager1.user_key])
-      end
-    end
-
-    context 'when legacy adminsets are found (e.g. adminsets created before Hyrax 2.1.0)' do
-      let!(:as_none) { build(:no_solr_grants_adminset, id: 'as_none', user: user) }
-      let!(:as_vu) { build(:no_solr_grants_adminset, id: 'as_vu', user: user, with_permission_template: { view_users: [reader1.user_key, reader2.user_key] }) }
-      let!(:as_vg) { build(:no_solr_grants_adminset, id: 'as_vg', user: user, with_permission_template: { view_groups: ['read_group_1', 'read_group_2'] }) }
-      let!(:as_du) { build(:no_solr_grants_adminset, id: 'as_du', user: user, with_permission_template: { deposit_users: [depositor1.user_key, depositor2.user_key] }) }
-      let!(:as_dg) { build(:no_solr_grants_adminset, id: 'as_dg', user: user, with_permission_template: { deposit_groups: ['deposit_group_1', 'deposit_group_2'] }) }
-      let!(:as_mu) { build(:no_solr_grants_adminset, id: 'as_mu', user: user, with_permission_template: { manage_users: [editor1.user_key, editor2.user_key] }) }
-      let!(:as_mg) { build(:no_solr_grants_adminset, id: 'as_mg', user: user, with_permission_template: { manage_groups: ['edit_group_1', 'edit_group_2'] }) }
-
-      before do
-        allow(AdminSet).to receive(:all).and_return([as_none, as_vu, as_vg, as_du, as_dg, as_mu, as_mg])
-      end
-
-      it 'sets read and edit access in solr doc' do # rubocop:disable RSpec/ExampleLength
-        AdminSet.all.each do |adminset|
-          expect(adminset.edit_users).to include(user.user_key)
-          expect(adminset.read_users).to eq []
-        end
-
-        Hyrax::Collections::MigrationService.migrate_all_collections
-
-        AdminSet.all.each do |adminset|
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id)
-          expect(pt_id).not_to be_nil
-          expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-          expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-          expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-          expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-          expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-          expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-        end
-      end
-    end
-
-    context 'when newer adminsets are found (e.g. adminsets created at or after Hyrax 2.1.0)' do
-      let!(:adminset) do
-        build(:adminset_lw,
-              id: 'as_newer', user: user,
-              with_permission_template: {
-                manage_users: [editor1.user_key, editor2.user_key],
-                deposit_users: [depositor1.user_key, depositor2.user_key],
-                view_users: [viewer1.user_key, viewer2.user_key],
-                manage_groups: ['manage_group_1', 'manage_group_2'],
-                deposit_groups: ['deposit_group_1', 'deposit_group_2'],
-                view_groups: ['view_group_1', 'view_group_2']
-              },
-              with_solr_document: true)
-      end
-      let!(:permission_template) { adminset.permission_template }
-      let!(:edit_users) { adminset.edit_users }
-
-      before do
-        allow(AdminSet).to receive(:all).and_return([adminset])
-      end
-
-      it "doesn't change the adminset" do # rubocop:disable RSpec/ExampleLength
-        pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id).id
-        expect(pt_id).to eq permission_template.id
-        expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-        expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-        expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-        expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-
-        Hyrax::Collections::MigrationService.migrate_all_collections
-
-        pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id).id
-        expect(pt_id).to eq permission_template.id
-        expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-        expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-        expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-        expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-      end
-    end
-  end
-
-  describe ".repair_migrated_collections" do
-    context 'when legacy collections are found (e.g. collections created before Hyrax 2.1.0)' do
-      let!(:col_none) { build(:typeless_collection, id: 'col_none', user: user, edit_users: [user.user_key], do_save: true) }
-      let!(:col_vu) { build(:typeless_collection, id: 'col_vu', user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key], do_save: true) }
-      let!(:col_vg) { build(:typeless_collection, id: 'col_vg', user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'], do_save: true) }
-      let!(:col_mu) { build(:typeless_collection, id: 'col_mu', user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key], do_save: true) }
-      let!(:col_mg) { build(:typeless_collection, id: 'col_mg', user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'], do_save: true) }
-
-      context "and collection wasn't migrated at all" do
-        let!(:col_none) { build(:typeless_collection_lw, user: user, edit_users: [user.user_key], read_users: [], do_save: true) }
-        let!(:col_vu) { build(:typeless_collection_lw, user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key], do_save: true) }
-        let!(:col_vg) { build(:typeless_collection_lw, user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'], do_save: true) }
-        let!(:col_mu) { build(:typeless_collection_lw, user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key], do_save: true) }
-        let!(:col_mg) { build(:typeless_collection_lw, user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'], do_save: true) }
-
-        it 'sets gid and adds permissions' do # rubocop:disable RSpec/ExampleLength
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to be_nil
-            expect { Hyrax::PermissionTemplate.find_by!(source_id: col.id) }.to raise_error ActiveRecord::RecordNotFound
-          end
-
-          Hyrax::Collections::MigrationService.repair_migrated_collections
-
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to eq default_gid
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_access(pt_id, 'user', :manage, col.edit_users)
-            expect_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_access(pt_id, 'user', :view, col.read_users)
-            expect_access(pt_id, 'group', :view, col.read_groups)
-          end
-        end
-      end
-
-      context "and collection type gid is set but permission template doesn't exist" do
-        let!(:col_none) { build(:user_collection_lw, id: 'col_none', user: user, edit_users: [user.user_key], collection_type_gid: default_gid) }
-        let!(:col_vu) { build(:user_collection_lw, id: 'col_vu', user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key], collection_type_gid: default_gid) }
-        let!(:col_vg) { build(:user_collection_lw, id: 'col_vg', user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'], collection_type_gid: default_gid) }
-        let!(:col_mu) { build(:user_collection_lw, id: 'col_mu', user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key], collection_type_gid: default_gid) }
-        let!(:col_mg) { build(:user_collection_lw, id: 'col_mg', user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'], collection_type_gid: default_gid) }
-
-        it 'sets gid and adds permissions' do # rubocop:disable RSpec/ExampleLength
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to eq default_gid
-            expect { Hyrax::PermissionTemplate.find_by!(source_id: col.id) }.to raise_error ActiveRecord::RecordNotFound
-          end
-
-          Hyrax::Collections::MigrationService.repair_migrated_collections
-
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to eq default_gid
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_access(pt_id, 'user', :manage, col.edit_users)
-            expect_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_access(pt_id, 'user', :view, col.read_users)
-            expect_access(pt_id, 'group', :view, col.read_groups)
-          end
-        end
-      end
-
-      context "and collection type gid isn't set but permission template exists with access set" do
-        let!(:col_none) { build(:typeless_collection, user: user, edit_users: [user.user_key], do_save: true, with_permission_template: true) }
-        let!(:col_vu) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_vg) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_mu) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_mg) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'],
-                                      do_save: true, with_permission_template: true)
-        end
-
-        before do
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col_none.id)
-          create_access(pt_id, 'user', :manage, [user.user_key])
-
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col_vu.id)
-          create_access(pt_id, 'user', :manage, [user.user_key])
-          create_access(pt_id, 'user', :view, col_vu.read_users)
-
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col_vg.id)
-          create_access(pt_id, 'user', :manage, [user.user_key])
-          create_access(pt_id, 'group', :view, col_vg.read_groups)
-
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col_mu.id)
-          create_access(pt_id, 'user', :manage, col_mu.edit_users)
-
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col_mg.id)
-          create_access(pt_id, 'user', :manage, [user.user_key])
-          create_access(pt_id, 'group', :manage, col_mg.edit_groups)
-        end
-
-        it 'sets gid' do # rubocop:disable RSpec/ExampleLength
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to be_nil
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_access(pt_id, 'user', :manage, col.edit_users)
-            expect_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_access(pt_id, 'user', :view, col.read_users)
-            expect_access(pt_id, 'group', :view, col.read_groups)
-          end
-
-          Hyrax::Collections::MigrationService.repair_migrated_collections
-
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to eq default_gid
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_access(pt_id, 'user', :manage, col.edit_users)
-            expect_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_access(pt_id, 'user', :view, col.read_users)
-            expect_access(pt_id, 'group', :view, col.read_groups)
-          end
-        end
-      end
-
-      context "and collection type gid isn't set and permission template exists with access not set" do
-        let!(:col_none) { build(:typeless_collection, user: user, edit_users: [user.user_key], do_save: true, with_permission_template: true) }
-        let!(:col_vu) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], read_users: [reader1.user_key, reader2.user_key],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_vg) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], read_groups: ['read_group_1', 'read_group_2'],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_mu) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key, editor1.user_key, editor2.user_key],
-                                      do_save: true, with_permission_template: true)
-        end
-        let!(:col_mg) do
-          build(:typeless_collection, user: user, edit_users: [user.user_key], edit_groups: ['edit_group_1', 'edit_group_2'],
-                                      do_save: true, with_permission_template: true)
-        end
-
-        it 'sets gid and adds access permissions' do # rubocop:disable RSpec/ExampleLength
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to be_nil
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_no_access(pt_id, 'user', :manage, col.edit_users)
-            expect_no_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_no_access(pt_id, 'user', :view, col.read_users)
-            expect_no_access(pt_id, 'group', :view, col.read_groups)
-          end
-
-          Hyrax::Collections::MigrationService.repair_migrated_collections
-
-          Collection.all.each do |col|
-            expect(col.collection_type_gid).to eq default_gid
-            pt_id = Hyrax::PermissionTemplate.find_by!(source_id: col.id)
-            expect(pt_id).not_to be_nil
-            expect_access(pt_id, 'user', :manage, col.edit_users)
-            expect_access(pt_id, 'group', :manage, col.edit_groups)
-            expect_access(pt_id, 'user', :view, col.read_users)
-            expect_access(pt_id, 'group', :view, col.read_groups)
-          end
-        end
-      end
-    end
-
-    context 'when newer collections are found (e.g. collections created at or after Hyrax 2.1.0)' do
-      let!(:collection) do
-        build(:collection_lw, id: 'col_newer', user: user, with_permission_template: true, collection_type_settings: [:discoverable],
-                              edit_users: [user.user_key])
-      end
-      let!(:permission_template) { collection.permission_template }
-      let!(:collection_type_gid) { collection.collection_type_gid }
-      let!(:edit_users) { collection.edit_users }
-
-      it "doesn't change the collection" do
-        expect(collection.collection_type_gid).to eq collection_type_gid
-        expect(Hyrax::PermissionTemplate.find_by!(source_id: collection.id).id).to eq permission_template.id
-        expect_access(permission_template.id, 'user', :manage, edit_users)
-
-        Hyrax::Collections::MigrationService.repair_migrated_collections
-
-        expect(collection.collection_type_gid).to eq collection_type_gid
-        expect(Hyrax::PermissionTemplate.find_by!(source_id: collection.id).id).to eq permission_template.id
-        expect_access(permission_template.id, 'user', :manage, edit_users)
-      end
-    end
-
-    context 'when legacy adminsets are found (e.g. adminsets created before Hyrax 2.1.0)' do
-      let!(:as_none) { build(:no_solr_grants_adminset, id: 'as_none', user: user) }
-      let!(:as_vu) { build(:no_solr_grants_adminset, id: 'as_vu', user: user, with_permission_template: { view_users: [reader1.user_key, reader2.user_key] }) }
-      let!(:as_vg) { build(:no_solr_grants_adminset, id: 'as_vg', user: user, with_permission_template: { view_groups: ['read_group_1', 'read_group_2'] }) }
-      let!(:as_du) { build(:no_solr_grants_adminset, id: 'as_du', user: user, with_permission_template: { deposit_users: [depositor1.user_key, depositor2.user_key] }) }
-      let!(:as_dg) { build(:no_solr_grants_adminset, id: 'as_dg', user: user, with_permission_template: { deposit_groups: ['deposit_group_1', 'deposit_group_2'] }) }
-      let!(:as_mu) { build(:no_solr_grants_adminset, id: 'as_mu', user: user, with_permission_template: { manage_users: [editor1.user_key, editor2.user_key] }) }
-      let!(:as_mg) { build(:no_solr_grants_adminset, id: 'as_mg', user: user, with_permission_template: { manage_groups: ['edit_group_1', 'edit_group_2'] }) }
-
-      before do
-        allow(AdminSet).to receive(:all).and_return([as_none, as_vu, as_vg, as_du, as_dg, as_mu, as_mg])
-      end
-
-      it 'sets read and edit access in solr doc' do # rubocop:disable RSpec/ExampleLength
-        AdminSet.all.each do |adminset|
-          expect(adminset.edit_users).to include(user.user_key)
-          expect(adminset.read_users).to eq []
-        end
-
-        Hyrax::Collections::MigrationService.repair_migrated_collections
-
-        AdminSet.all.each do |adminset|
-          pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id)
-          expect(pt_id).not_to be_nil
-          expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-          expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-          expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-          expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-          expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-          expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-        end
-      end
-    end
-
-    context 'when newer adminsets are found (e.g. adminsets created at or after Hyrax 2.1.0)' do
-      let!(:adminset) do
-        build(:adminset_lw,
-              id: 'as_newer', user: user,
-              with_permission_template: {
-                manage_users: [editor1.user_key, editor2.user_key],
-                deposit_users: [depositor1.user_key, depositor2.user_key],
-                view_users: [viewer1.user_key, viewer2.user_key],
-                manage_groups: ['manage_group_1', 'manage_group_2'],
-                deposit_groups: ['deposit_group_1', 'deposit_group_2'],
-                view_groups: ['view_group_1', 'view_group_2']
-              },
-              with_solr_document: true)
-      end
-      let!(:permission_template) { adminset.permission_template }
-      let!(:edit_users) { adminset.edit_users }
-
-      before do
-        allow(AdminSet).to receive(:all).and_return([adminset])
-      end
-
-      it "doesn't change the adminset" do # rubocop:disable RSpec/ExampleLength
-        pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id).id
-        expect(pt_id).to eq permission_template.id
-        expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-        expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-        expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-        expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-
-        Hyrax::Collections::MigrationService.repair_migrated_collections
-
-        pt_id = Hyrax::PermissionTemplate.find_by!(source_id: adminset.id).id
-        expect(pt_id).to eq permission_template.id
-        expect_solr_access(pt_id, 'user', :manage, adminset.edit_users)
-        expect_solr_access(pt_id, 'group', :manage, adminset.edit_groups)
-        expect_solr_access(pt_id, 'user', :deposit, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :deposit, adminset.read_groups)
-        expect_solr_access(pt_id, 'user', :view, adminset.read_users)
-        expect_solr_access(pt_id, 'group', :view, adminset.read_groups)
-      end
-    end
-  end
-
-  def create_access(permission_template_id, agent_type, access, agent_ids)
-    agent_ids.each do |agent_id|
-      create(:permission_template_access,
-             access,
-             permission_template: permission_template_id,
-             agent_type: agent_type,
-             agent_id: agent_id)
-    end
-  end
-
-  def expect_access(permission_template_id, agent_type, access, agent_ids)
-    agent_ids.each do |agent_id|
-      pta = Hyrax::PermissionTemplateAccess.where(permission_template_id: permission_template_id, agent_type: agent_type,
-                                                  access: access, agent_id: agent_id)
-      expect(pta).not_to be_empty
-    end
-  end
-
-  def expect_no_access(permission_template_id, agent_type, access, agent_ids)
-    agent_ids.each do |agent_id|
-      pta = Hyrax::PermissionTemplateAccess.where(permission_template_id: permission_template_id, agent_type: agent_type,
-                                                  access: access, agent_id: agent_id)
-      expect(pta).to be_empty
-    end
-  end
-
-  def expect_solr_access(permission_template_id, pt_agent_type, pt_access, solrdoc_access)
-    ptas = Hyrax::PermissionTemplateAccess.where(permission_template_id: permission_template_id, agent_type: pt_agent_type, access: pt_access)
-    expect_solr_group_access(ptas, solrdoc_access) if pt_agent_type == 'group'
-    expect_solr_user_access(ptas, solrdoc_access) if pt_agent_type == 'user'
-  end
-
-  def expect_solr_group_access(permission_templates, solrdoc_access)
-    permission_templates.each do |pta|
-      expect(solrdoc_access).to include pta.agent_id
-    end
-  end
-
-  def expect_solr_user_access(permission_templates, solrdoc_access)
-    permission_templates.each do |pta|
-      expect(solrdoc_access).to include pta.agent_id
-    end
-  end
-end