hyrax 2.6.0 → 2.9.0

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

@@ -1,28 +0,0 @@
-RSpec.describe Hyrax::Collections::NestedCollectionPersistenceService, with_nested_reindexing: true do
-  let(:parent) { build(:collection_lw) }
-  let(:child) { create(:collection) }
-
-  describe '.persist_nested_collection_for' do
-    subject { described_class.persist_nested_collection_for(parent: parent, child: child) }
-
-    it 'creates the relationship between parent and child' do
-      subject
-      expect(parent.member_objects).to eq([child])
-      expect(child.member_of_collections).to eq([parent])
-    end
-  end
-
-  describe '.remove_nested_relationship_for', :clean_repo do
-    subject { described_class.remove_nested_relationship_for(parent: parent, child: child) }
-
-    before do
-      described_class.persist_nested_collection_for(parent: parent, child: child)
-    end
-
-    it 'removes the relationship between parent and child' do
-      subject
-      expect(parent.member_objects).to eq([])
-      expect(child.member_of_collections).to eq([])
-    end
-  end
-end

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

@@ -1,353 +0,0 @@
-RSpec.describe Hyrax::Collections::NestedCollectionQueryService, clean_repo: true do
-  let(:blacklight_config) { CatalogController.blacklight_config }
-  let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
-  let(:user) { create(:user) }
-  let(:ability) { ::Ability.new(user) }
-  let(:current_ability) { ability }
-  let(:scope) { double('Scope', can?: true, current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
-
-  let(:collection_type) { create(:collection_type) }
-  let(:another_collection_type) { create(:collection_type) }
-
-  let(:coll_a) do
-    build(:public_collection,
-          id: 'Collection_A',
-          collection_type_gid: collection_type.gid,
-          with_nesting_attributes:
-          { ancestors: [],
-            parent_ids: [],
-            pathnames: ['Collection_A'],
-            depth: 1 })
-  end
-  let(:coll_b) do
-    build(:public_collection,
-          id: 'Collection_B',
-          collection_type_gid: collection_type.gid,
-          member_of_collections: [coll_a],
-          with_nesting_attributes:
-          { ancestors: ['Collection_A'],
-            parent_ids: ['Collection_A'],
-            pathnames: ['Collection_A/Collection_B'],
-            depth: 2 })
-  end
-  let(:coll_c) do
-    build(:public_collection,
-          id: 'Collection_C',
-          collection_type_gid: collection_type.gid,
-          member_of_collections: [coll_b],
-          with_nesting_attributes:
-          { ancestors: ["Collection_A",
-                        "Collection_A/Collection_B"],
-            parent_ids: ['Collection_B'],
-            pathnames: ['Collection_A/Collection_B/Collection_C'],
-            depth: 3 })
-  end
-  let(:coll_d) do
-    build(:public_collection,
-          id: 'Collection_D',
-          collection_type_gid: collection_type.gid,
-          member_of_collections: [coll_c],
-          with_nesting_attributes:
-          { ancestors: ["Collection_A",
-                        "Collection_A/Collection_B",
-                        "Collection_A/Collection_B/Collection_C"],
-            parent_ids: ['Collection_C'],
-            pathnames: ["Collection_A/Collection_B/Collection_C/Collection_D"],
-            depth: 4 })
-  end
-  let(:coll_e) do
-    build(:public_collection,
-          id: 'Collection_E',
-          collection_type_gid: collection_type.gid,
-          member_of_collections: [coll_d],
-          with_nesting_attributes:
-          { ancestors: ["Collection_A",
-                        "Collection_A/Collection_B",
-                        "Collection_A/Collection_B/Collection_C",
-                        "Collection_A/Collection_B/Collection_C/Collection_D"],
-            parent_ids: ['Collection_D'],
-            pathnames: ['Collection_A/Collection_B/Collection_C/Collection_D/Collection_E'],
-            depth: 5 })
-  end
-  let(:another) do
-    build(:public_collection,
-          id: 'Another_One',
-          collection_type_gid: collection_type.gid,
-          with_nesting_attributes:
-          { ancestors: [],
-            parent_ids: [],
-            pathnames: ['Another_One'],
-            depth: 1 })
-  end
-  let(:wrong) do
-    build(:public_collection,
-          id: 'Wrong_Type',
-          collection_type_gid: another_collection_type.gid,
-          with_nesting_attributes:
-          { ancestors: [],
-            parent_ids: [],
-            pathnames: ['Wrong_Type'],
-            depth: 1 })
-  end
-
-  describe '.available_child_collections' do
-    describe 'given parent is not nestable?' do
-      subject { described_class.available_child_collections(parent: parent_double, scope: scope) }
-
-      let(:parent_double) { double(nestable?: false) }
-
-      it { is_expected.to eq([]) }
-    end
-
-    describe 'given parent is nestable?' do
-      subject { described_class.available_child_collections(parent: coll_c, scope: scope) }
-
-      before do
-        coll_e # this will also build coll_a through coll_d
-        another
-        wrong
-      end
-
-      describe 'and cannot deposit to the parent' do
-        it 'returns an empty array' do
-          expect(scope).to receive(:can?).with(:deposit, coll_c).and_return(false)
-          expect(described_class).not_to receive(:query_solr)
-          expect(subject).to eq([])
-        end
-      end
-
-      describe 'and can deposit to the parent' do
-        describe 'it prevents circular nesting' do
-          it 'returns an array of valid collections of the same collection type' do
-            expect(scope).to receive(:can?).with(:deposit, coll_c).and_return(true)
-            expect(described_class).to receive(:query_solr).with(collection: coll_c, access: :read, scope: scope, limit_to_id: nil, nest_direction: :as_child).and_call_original
-            expect(subject.map(&:id)).to contain_exactly(another.id, coll_e.id)
-          end
-        end
-      end
-    end
-  end
-
-  describe '.available_parent_collections' do
-    describe 'given child is not nestable?' do
-      subject { described_class.available_parent_collections(child: child_double, scope: scope) }
-
-      let(:child_double) { double(nestable?: false) }
-
-      it { is_expected.to eq([]) }
-    end
-
-    describe 'given child is nestable?' do
-      describe 'and cannot read the child' do
-        subject { described_class.available_parent_collections(child: coll_c, scope: scope) }
-
-        it 'returns an empty array' do
-          expect(scope).to receive(:can?).with(:read, coll_c).and_return(false)
-          expect(described_class).not_to receive(:query_solr)
-          expect(subject).to eq([])
-        end
-      end
-
-      describe 'and can read the child', with_nested_reindexing: true do
-        subject { described_class.available_parent_collections(child: coll_c, scope: scope) }
-
-        # using create option here because permission template is required for testing :deposit access
-        let(:coll_a) do
-          build(:public_collection_lw,
-                id: 'Collection_A',
-                collection_type_gid: collection_type.gid,
-                user: user,
-                with_permission_template: true)
-        end
-        let(:coll_b) do
-          build(:public_collection_lw,
-                id: 'Collection_B',
-                collection_type_gid: collection_type.gid,
-                user: user,
-                with_permission_template: true,
-                member_of_collections: [coll_a])
-        end
-        let(:coll_c) do
-          build(:public_collection_lw,
-                id: 'Collection_C',
-                collection_type_gid: collection_type.gid,
-                user: user,
-                with_permission_template: true,
-                member_of_collections: [coll_b])
-        end
-        let(:coll_d) do
-          build(:public_collection_lw,
-                id: 'Collection_D',
-                collection_type_gid: collection_type.gid,
-                user: user,
-                with_permission_template: true,
-                member_of_collections: [coll_c])
-        end
-        let(:coll_e) do
-          create(:public_collection_lw,
-                 id: 'Collection_E',
-                 collection_type_gid: collection_type.gid,
-                 user: user,
-                 with_permission_template: true,
-                 member_of_collections: [coll_d])
-        end
-        let(:another) do
-          create(:public_collection_lw,
-                 id: 'Another_One',
-                 collection_type_gid: collection_type.gid,
-                 user: user,
-                 with_permission_template: true)
-        end
-        let(:wrong) do
-          build(:public_collection_lw,
-                id: 'Wrong_Type',
-                collection_type_gid: another_collection_type.gid,
-                user: user,
-                with_permission_template: true)
-        end
-
-        before do
-          coll_e # this will also build coll_a through coll_d
-          another
-          wrong
-        end
-
-        describe 'it prevents circular nesting' do
-          it 'returns an array of collections of the same collection type excluding the given collection' do
-            expect(scope).to receive(:can?).with(:read, coll_c).and_return(true)
-            expect(described_class).to receive(:query_solr).with(collection: coll_c, access: :deposit, scope: scope, limit_to_id: nil, nest_direction: :as_parent).and_call_original
-            expect(subject.map(&:id)).to contain_exactly(coll_a.id, another.id)
-          end
-        end
-      end
-    end
-  end
-
-  describe '.parent_and_child_can_nest?' do
-    let(:parent) { coll_c }
-    let(:child) { another }
-
-    subject { described_class.parent_and_child_can_nest?(parent: parent, child: child, scope: scope) }
-
-    before do
-      coll_e
-      another
-      wrong
-    end
-
-    describe 'given parent and child are nestable' do
-      describe 'and are the same object' do
-        let(:child) { parent }
-
-        it { is_expected.to eq(false) }
-      end
-
-      describe 'and are of the same collection type', with_nested_reindexing: true do
-        # using create option here because permission template is required for testing :deposit access
-        let!(:parent) do
-          create(:public_collection_lw,
-                 id: 'Parent_Collecton',
-                 collection_type_gid: collection_type.gid,
-                 user: user,
-                 with_permission_template: true)
-        end
-        let!(:child) do
-          create(:public_collection_lw,
-                 id: 'Child_Collection',
-                 collection_type_gid: collection_type.gid,
-                 user: user,
-                 with_permission_template: true)
-        end
-
-        it { is_expected.to eq(true) }
-      end
-      describe 'and the ability does not permit the actions' do
-        before do
-          expect(scope).to receive(:can?).and_return(false)
-        end
-
-        it { is_expected.to eq(false) }
-      end
-      describe 'and are of different collection types' do
-        let(:parent) { double(nestable?: true, collection_type_gid: 'another', id: 'parent_collection') }
-
-        it { is_expected.to eq(false) }
-      end
-    end
-
-    describe 'given parent is not nestable?' do
-      let(:parent) { double(nestable?: false, collection_type_gid: 'same', id: 'parent_collection') }
-
-      it { is_expected.to eq(false) }
-    end
-    describe 'given child is not nestable?' do
-      let(:child) { double(nestable?: false, collection_type_gid: 'same', id: 'child_collection') }
-
-      it { is_expected.to eq(false) }
-    end
-    describe 'not in available parent collections' do
-      before do
-        allow(described_class).to receive(:available_parent_collections).with(child: child, scope: scope, limit_to_id: parent.id).and_return([])
-      end
-
-      it { is_expected.to eq(false) }
-    end
-    describe 'not in available child collections' do
-      before do
-        allow(described_class).to receive(:available_child_collections).with(parent: parent, scope: scope, limit_to_id: child.id).and_return([])
-      end
-
-      it { is_expected.to eq(false) }
-    end
-  end
-
-  describe '.valid_combined_nesting_depth?' do
-    subject { described_class.valid_combined_nesting_depth?(parent: parent, child: child, scope: scope) }
-
-    context 'when total depth > limit' do
-      let(:parent) { coll_e }
-      let(:child) { another }
-
-      it 'returns false' do
-        expect(subject).to eq false
-      end
-    end
-
-    context 'when valid combined depth' do
-      let(:parent) { coll_c }
-      let(:child) { coll_e }
-
-      it 'returns true' do
-        expect(subject).to eq true
-      end
-    end
-  end
-
-  describe 'nesting attributes object', with_nested_reindexing: true do
-    let(:user) { create(:user) }
-    let!(:parent) { build(:collection_lw, id: 'Parent_Coll', collection_type_gid: collection_type.gid, user: user) }
-    let!(:child) { create(:user_collection_lw, id: 'Child_Coll', collection_type_gid: collection_type.gid, user: user) }
-    let(:nesting_attributes) { Hyrax::Collections::NestedCollectionQueryService::NestingAttributes.new(id: child.id, scope: scope) }
-
-    before do
-      Hyrax::Collections::NestedCollectionPersistenceService.persist_nested_collection_for(parent: parent, child: child)
-    end
-
-    it 'will respond to expected methods' do
-      expect(nesting_attributes).to respond_to(:id)
-      expect(nesting_attributes).to respond_to(:parents)
-      expect(nesting_attributes).to respond_to(:pathnames)
-      expect(nesting_attributes).to respond_to(:ancestors)
-      expect(nesting_attributes).to respond_to(:depth)
-    end
-
-    it 'will encapsulate the nesting attributes in an object' do
-      expect(nesting_attributes).to be_a(Hyrax::Collections::NestedCollectionQueryService::NestingAttributes)
-      expect(nesting_attributes.id).to eq('Child_Coll')
-      expect(nesting_attributes.parents).to eq(['Parent_Coll'])
-      expect(nesting_attributes.pathnames).to eq(['Parent_Coll/Child_Coll'])
-      expect(nesting_attributes.ancestors).to eq(['Parent_Coll'])
-      expect(nesting_attributes.depth).to eq(2)
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-RSpec.describe Hyrax::Collections::PermissionsCreateService do
-  let(:user) { create(:user) }
-  let(:user2) { create(:user) }
-
-  describe ".create_default" do
-    subject { described_class.create_default(collection: collection, creating_user: user) }
-
-    let(:collection_type) { create(:collection_type) }
-    let(:user_manage_attributes) do
-      {
-        hyrax_collection_type_id: collection_type.id,
-        access: 'manage',
-        agent_id: user2.user_key,
-        agent_type: 'user'
-      }
-    end
-    let(:group_manage_attributes) do
-      {
-        hyrax_collection_type_id: collection_type.id,
-        access: 'manage',
-        agent_id: 'manage_group',
-        agent_type: 'group'
-      }
-    end
-    let!(:collection_type_participant) { create(:collection_type_participant, user_manage_attributes) }
-    let!(:collection_type_participant2) { create(:collection_type_participant, group_manage_attributes) }
-    let(:collection) { build(:collection_lw, id: 'collection1', collection_type_gid: collection_type.gid) }
-
-    before do
-      subject
-    end
-
-    it "creates the default permission template for the collection" do
-      expect(Hyrax::PermissionTemplate.find_by_source_id(collection.id)).to be_persisted
-    end
-
-    it "creates the default permission template access entries for the collection" do
-      expect(Hyrax::PermissionTemplate.find_by_source_id(collection.id).access_grants.count).to eq 4
-    end
-  end
-
-  describe ".add_access" do
-    subject { described_class.add_access(collection_id: collection.id, grants: grants) }
-    let(:collection) { build(:collection_lw, id: 'test_collection', with_permission_template: true) }
-    let(:grants) do
-      [{ agent_type: Hyrax::PermissionTemplateAccess::GROUP,
-         agent_id: 'archivist',
-         access: Hyrax::PermissionTemplateAccess::DEPOSIT }]
-    end
-    let(:depositor_grants) { collection.permission_template.access_grants.deposit }
-    let(:array) { [] }
-
-    before do
-      allow(ActiveFedora::Base).to receive(:find).with(collection.id).and_return(collection)
-      allow(collection).to receive(:reset_access_controls!).and_return true
-      subject
-      depositor_grants.each { |agent| array << agent.agent_id }
-    end
-
-    it 'gives deposit access to archivist group' do
-      expect(array.include?("archivist")).to eq true
-    end
-  end
-end

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

@@ -1,380 +0,0 @@
-RSpec.describe Hyrax::Collections::PermissionsService do
-  let(:user) { create(:user, email: 'user@example.com') }
-
-  let(:ability) { Ability.new(user) }
-
-  context 'collection specific methods' do
-    let(:collection) { build(:collection_lw, id: 'collection_1') }
-    let(:admin_set) { build(:admin_set, id: 'adminset_1') }
-    let(:col_permission_template) { create(:permission_template, source_id: collection.id) }
-    let(:as_permission_template) { create(:permission_template, source_id: admin_set.id) }
-
-    before do
-      allow(Hyrax::PermissionTemplate).to receive(:find_by!).with(source_id: collection.id).and_return(col_permission_template)
-      allow(ability).to receive(:user_groups).and_return(['public', 'registered'])
-    end
-
-    context 'when manage user' do
-      before do
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([user.user_key])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return([])
-      end
-
-      subject { described_class }
-
-      it '.can_deposit_in_collection? returns true' do
-        expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be true
-      end
-      it '.can_view_admin_show_for_collection? returns true' do
-        expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be true
-      end
-    end
-
-    context 'when deposit user' do
-      before do
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([user.user_key])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return([])
-      end
-
-      subject { described_class }
-
-      it '.can_deposit_in_collection? returns true' do
-        expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be true
-      end
-      it '.can_view_admin_show_for_collection? returns true' do
-        expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be true
-      end
-    end
-
-    context 'when view user' do
-      before do
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([user.user_key])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return([])
-        allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return([])
-      end
-
-      subject { described_class }
-
-      it '.can_deposit_in_collection? returns false' do
-        expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be false
-      end
-      it '.can_view_admin_show_for_collection? returns true' do
-        expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be true
-      end
-    end
-
-    context 'when deposit user' do
-      context 'thru membership in public group' do
-        before do
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return(['public'])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return([])
-        end
-
-        subject { described_class }
-
-        it '.can_deposit_in_collection? returns true' do
-          expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be true
-        end
-        it '.can_view_admin_show_for_collection? returns false' do
-          expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-      end
-
-      context 'thru membership in registered group' do
-        before do
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return(['registered'])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return([])
-        end
-
-        subject { described_class }
-
-        it '.can_deposit_in_collection? returns true' do
-          expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be true
-        end
-        it '.can_view_admin_show_for_collection? returns false' do
-          expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-      end
-    end
-
-    context 'when view user' do
-      context 'thru membership in public group' do
-        before do
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return(['public'])
-        end
-
-        subject { described_class }
-
-        it '.can_deposit_in_collection? returns false' do
-          expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-        it '.can_view_admin_show_for_collection? returns false' do
-          expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-      end
-
-      context 'thru membership in registered group' do
-        before do
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'user', access: 'view').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'manage').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'deposit').and_return([])
-          allow(col_permission_template).to receive(:agent_ids_for).with(agent_type: 'group', access: 'view').and_return(['registered'])
-        end
-
-        subject { described_class }
-
-        it '.can_deposit_in_collection? returns false' do
-          expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-        it '.can_view_admin_show_for_collection? returns false' do
-          expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be false
-        end
-      end
-    end
-
-    context 'when user without access' do
-      subject { described_class }
-
-      it '.can_deposit_in_collection? returns false' do
-        expect(subject.can_deposit_in_collection?(collection_id: collection.id, ability: ability)).to be false
-      end
-      it '.can_view_admin_show_for_collection? returns false' do
-        expect(subject.can_view_admin_show_for_collection?(collection_id: collection.id, ability: ability)).to be false
-      end
-    end
-  end
-
-  context 'methods returning ids' do
-    let(:user1) { create(:user, email: 'user1@example.com') }
-    let(:user2) { create(:user, email: 'user2@example.com') }
-
-    let!(:col_vu) do
-      build(:collection_lw, id: 'collection_vu', user: user1, with_solr_document: true,
-                            with_permission_template: { view_users: [user] })
-    end
-    let!(:col_vg) do
-      build(:collection_lw, id: 'collection_vg', user: user1, with_solr_document: true,
-                            with_permission_template: { view_groups: ['view_group'] })
-    end
-    let!(:col_mu) do
-      build(:collection_lw, id: 'collection_mu', user: user1, with_solr_document: true,
-                            with_permission_template: { manage_users: [user] })
-    end
-    let!(:col_mg) do
-      build(:collection_lw, id: 'collection_mg', user: user1, with_solr_document: true,
-                            with_permission_template: { manage_groups: ['manage_group'] })
-    end
-    let!(:col_du) do
-      build(:collection_lw, id: 'collection_du', user: user1, with_solr_document: true,
-                            with_permission_template: { deposit_users: [user] })
-    end
-    let!(:col_dg) do
-      build(:collection_lw, id: 'collection_dg', user: user1, with_solr_document: true,
-                            with_permission_template: { deposit_groups: ['deposit_group'] })
-    end
-
-    let(:as_vu) { create(:admin_set, id: 'adminset_vu', with_permission_template: true) }
-    let(:as_vg) { create(:admin_set, id: 'adminset_vg', with_permission_template: true) }
-    let(:as_mu) { create(:admin_set, id: 'adminset_mu', with_permission_template: true) }
-    let(:as_mg) { create(:admin_set, id: 'adminset_mg', with_permission_template: true) }
-    let(:as_du) { create(:admin_set, id: 'adminset_du', with_permission_template: true) }
-    let(:as_dg) { create(:admin_set, id: 'adminset_dg', with_permission_template: true) }
-
-    before do
-      source_access(as_vu.permission_template, 'user', user.user_key, :view)
-      source_access(as_vg.permission_template, 'group', 'view_group', :view)
-      source_access(as_mu.permission_template, 'user', user.user_key, :manage)
-      source_access(as_mg.permission_template, 'group', 'manage_group', :manage)
-      source_access(as_du.permission_template, 'user', user.user_key, :deposit)
-      source_access(as_dg.permission_template, 'group', 'deposit_group', :deposit)
-
-      allow(user).to receive(:groups).and_return(['view_group', 'deposit_group', 'manage_group'])
-    end
-
-    describe '.collection_ids_for_user' do
-      it 'returns collection ids where user has manage access' do
-        expect(described_class.collection_ids_for_user(access: 'manage', ability: ability)).to match_array [col_mu.id, col_mg.id]
-      end
-      it 'returns collection ids where user has deposit access' do
-        expect(described_class.collection_ids_for_user(access: 'deposit', ability: ability)).to match_array [col_du.id, col_dg.id]
-      end
-      it 'returns collection ids where user has view access' do
-        expect(described_class.collection_ids_for_user(access: 'view', ability: ability)).to match_array [col_vu.id, col_vg.id]
-      end
-      it 'returns collection ids where user has manage, deposit, or view access' do
-        all = [col_mu.id, col_mg.id, col_du.id, col_dg.id, col_vu.id, col_vg.id]
-        expect(described_class.collection_ids_for_user(access: ['manage', 'deposit', 'view'], ability: ability)).to match_array all
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns empty array' do
-          expect(described_class.collection_ids_for_user(access: ['manage', 'deposit', 'view'], ability: ability)).to match_array []
-        end
-      end
-    end
-
-    describe '.source_ids_for_manage' do
-      it 'returns collection and admin set ids where user has manage access' do
-        expect(described_class.source_ids_for_manage(ability: ability)).to match_array [col_mu.id, col_mg.id, as_mu.id, as_mg.id]
-      end
-      it 'returns collection ids where user has manage access' do
-        expect(described_class.source_ids_for_manage(ability: ability, source_type: 'collection')).to match_array [col_mu.id, col_mg.id]
-      end
-      it 'returns admin set ids where user has manage access' do
-        expect(described_class.source_ids_for_manage(ability: ability, source_type: 'admin_set')).to match_array [as_mu.id, as_mg.id]
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns empty array' do
-          expect(described_class.source_ids_for_manage(ability: ability)).to match_array []
-        end
-      end
-    end
-
-    describe '.source_ids_for_deposit' do
-      it 'returns collection and admin set ids where user has deposit access' do
-        expect(described_class.source_ids_for_deposit(ability: ability)).to match_array [col_du.id, col_dg.id, col_mu.id, col_mg.id, as_du.id, as_dg.id, as_mu.id, as_mg.id]
-      end
-      it 'returns collection ids where user has deposit access' do
-        expect(described_class.source_ids_for_deposit(ability: ability, source_type: 'collection')).to match_array [col_du.id, col_dg.id, col_mu.id, col_mg.id]
-      end
-      it 'returns admin set ids where user has deposit access' do
-        expect(described_class.source_ids_for_deposit(ability: ability, source_type: 'admin_set')).to match_array [as_du.id, as_dg.id, as_mu.id, as_mg.id]
-      end
-      it 'returns admin set ids where user has deposit access except excluded groups' do
-        expect(described_class.source_ids_for_deposit(ability: ability, source_type: 'admin_set', exclude_groups: ['deposit_group']))
-          .to match_array [as_du.id, as_mu.id, as_mg.id]
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns empty array' do
-          expect(described_class.source_ids_for_deposit(ability: ability)).to match_array []
-        end
-      end
-    end
-
-    describe '.collection_ids_for_deposit' do
-      it 'returns collection ids where user has manage access' do
-        expect(described_class.collection_ids_for_deposit(ability: ability)).to match_array [col_du.id, col_dg.id, col_mu.id, col_mg.id]
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns empty array' do
-          expect(described_class.collection_ids_for_deposit(ability: ability)).to match_array []
-        end
-      end
-    end
-
-    describe '.collection_ids_for_view' do
-      it 'returns collection ids where user has view access' do
-        expect(described_class.collection_ids_for_view(ability: ability)).to match_array [col_du.id, col_dg.id, col_mu.id, col_mg.id, col_vu.id, col_vg.id]
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns empty array' do
-          expect(described_class.collection_ids_for_view(ability: ability)).to match_array []
-        end
-      end
-    end
-
-    describe '.can_manage_any_collection?' do
-      it 'returns true when user has manage access to at least one collection' do
-        expect(described_class.can_manage_any_collection?(ability: ability)).to be true
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns false' do
-          expect(described_class.can_manage_any_collection?(ability: ability)).to be false
-        end
-      end
-    end
-
-    describe '.can_manage_any_admin_set?' do
-      it 'returns true when user has manage access to at least one admin set' do
-        expect(described_class.can_manage_any_admin_set?(ability: ability)).to be true
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns false' do
-          expect(described_class.can_manage_any_admin_set?(ability: ability)).to be false
-        end
-      end
-    end
-
-    describe '.can_view_admin_show_for_any_collection?' do
-      it 'returns true when user has manage, deposit, or view access to at least one collection' do
-        expect(described_class.can_view_admin_show_for_any_collection?(ability: ability)).to be true
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns false' do
-          expect(described_class.can_view_admin_show_for_any_collection?(ability: ability)).to be false
-        end
-      end
-    end
-
-    describe '.can_view_admin_show_for_any_admin set?' do
-      it 'returns true when user has manage, deposit, or view access to at least one admin set' do
-        expect(described_class.can_view_admin_show_for_any_admin_set?(ability: ability)).to be true
-      end
-
-      context 'when user has no access' do
-        let(:ability) { Ability.new(user2) }
-
-        it 'returns false' do
-          expect(described_class.can_view_admin_show_for_any_admin_set?(ability: ability)).to be false
-        end
-      end
-    end
-  end
-
-  def source_access(permission_template, agent_type, agent_id, access)
-    create(:permission_template_access,
-           access,
-           permission_template: permission_template,
-           agent_type: agent_type,
-           agent_id: agent_id)
-  end
-end