hyrax 2.9.5 → 3.0.0.pre.beta1

data/spec/services/hyrax/admin_set_member_service_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe Hyrax::AdminSetMemberService, 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', current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
+
+  let(:admin_set) { build(:admin_set) }
+  let(:builder) { described_class.new(scope: scope, collection: admin_set, params: { "id" => admin_set.id.to_s }) }
+  let(:subject) { builder.available_member_works }
+  let(:ids) { subject.response[:docs].map { |col| col[:id] } }
+
+  describe '#available_member_works' do
+    let!(:work1) { create(:generic_work, admin_set: admin_set) }
+    let!(:work2) { create(:generic_work) }
+    let!(:work3) { create(:generic_work, admin_set: admin_set) }
+
+    it 'returns the members of the admin set' do
+      expect(ids).to contain_exactly(work1.id, work3.id)
+    end
+  end
+end

data/spec/services/hyrax/admin_set_service_spec.rb

@@ -0,0 +1,171 @@
+RSpec.describe Hyrax::AdminSetService do
+  let(:controller) { ::CatalogController.new }
+  let(:context) do
+    double(current_ability: Ability.new(user),
+           repository: controller.repository,
+           blacklight_config: controller.blacklight_config)
+  end
+  let(:service) { described_class.new(context) }
+  let(:user) { create(:user) }
+
+  describe "#search_results", :clean_repo do
+    subject { service.search_results(access) }
+
+    let!(:as1) { create(:admin_set, read_groups: ['public'], title: ['foo']) }
+    let!(:as2) { create(:admin_set, read_groups: ['public'], title: ['bar']) }
+    let!(:as3) { create(:admin_set, edit_users: [user.user_key], title: ['baz']) }
+
+    before do
+      create(:collection, :public) # this should never be returned.
+    end
+
+    context "with read access" do
+      let(:access) { :read }
+
+      it "returns three admin sets" do
+        expect(subject.map(&:id)).to match_array [as1.id, as2.id, as3.id]
+      end
+    end
+
+    context "with edit access" do
+      let(:access) { :edit }
+
+      it "returns one admin set" do
+        expect(subject.map(&:id)).to match_array [as3.id]
+      end
+    end
+  end
+
+  context "with injection" do
+    subject { service.search_results(access) }
+
+    let(:service) { described_class.new(context, search_builder) }
+    let(:access) { :edit }
+    let(:search_builder) { double(new: search_builder_instance) }
+    let(:search_builder_instance) { double }
+
+    it "calls the injected search builder" do
+      expect(search_builder_instance).to receive(:rows).and_return(search_builder_instance)
+      expect(search_builder_instance).to receive(:reverse_merge).and_return({})
+      subject
+    end
+  end
+
+  describe '#search_results_with_work_count', :clean_repo do
+    subject { service.search_results_with_work_count(access) }
+
+    let(:admin_set_attrs) do
+      [
+        { id: 'admin_set_1' },
+        { id: 'admin_set_2' },
+        { id: 'admin_set_3' }
+      ]
+    end
+
+    let(:file_set_attrs) do
+      [
+        { id: 'file_1', has_model_ssim: 'FileSet' },
+        { id: 'file_2', has_model_ssim: 'FileSet' },
+        { id: 'file_3', has_model_ssim: 'FileSet' },
+        { id: 'file_4', has_model_ssim: 'FileSet' },
+        { id: 'file_5', has_model_ssim: 'FileSet' },
+        { id: 'file_6', has_model_ssim: 'FileSet' },
+        { id: 'file_7', has_model_ssim: 'FileSet' },
+        { id: 'file_8', has_model_ssim: 'FileSet' },
+        { id: 'file_9', has_model_ssim: 'FileSet' },
+        { id: 'file_10', has_model_ssim: 'FileSet' },
+        { id: 'file_11', has_model_ssim: 'FileSet' }
+      ]
+    end
+
+    let(:work1_attrs) { { id: 'work_1' } }
+    let(:work2_attrs) { { id: 'work_2' } }
+    let(:work3_attrs) { { id: 'work_3' } }
+    let(:work4_attrs) { { id: 'work_4' } }
+    let(:work5_attrs) { { id: 'work_5' } }
+    let(:work6_attrs) { { id: 'work_6' } }
+    let(:work7_attrs) { { id: 'work_7' } }
+    let(:work8_attrs) { { id: 'work_8' } }
+    let(:work9_attrs) { { id: 'work_9' } }
+    let(:work10_attrs) { { id: 'work_10' } }
+    let(:work11_attrs) { { id: 'work_11' } }
+
+    let(:work_attrs) { [work1_attrs, work2_attrs, work3_attrs, work4_attrs, work5_attrs, work6_attrs, work7_attrs, work8_attrs, work9_attrs, work10_attrs, work11_attrs] }
+
+    let(:works) do
+      [].tap do |result|
+        work_attrs.each do |work|
+          result << SolrDocument.new(work)
+        end
+      end
+    end
+
+    let(:admin_sets) do
+      [].tap do |result|
+        admin_set_attrs.each do |admin_set|
+          result << SolrDocument.new(admin_set)
+        end
+      end
+    end
+
+    let(:file_sets) do
+      [].tap do |result|
+        file_set_attrs.each do |file_set|
+          result << SolrDocument.new(file_set)
+        end
+      end
+    end
+
+    let(:access) { :read }
+    let(:struct) { described_class::SearchResultForWorkCount }
+
+    before do
+      allow(service).to receive(:search_results).and_return(admin_sets)
+      all_objects = []
+      all_objects << works << admin_sets << file_sets
+      all_objects.each do |obj|
+        ActiveFedora::SolrService.add(obj)
+      end
+      ActiveFedora::SolrService.commit
+    end
+
+    context "when there are works and files in the admin set" do
+      let(:work1_attrs) { { id: 'work_1', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_1', 'file_3', 'file_4'] } }
+      let(:work2_attrs) { { id: 'work_2', isPartOf_ssim: 'admin_set_2', file_set_ids_ssim: ['file_2'] } }
+      let(:work3_attrs) { { id: 'work_3', isPartOf_ssim: 'admin_set_2', file_set_ids_ssim: ['file_6', 'file_7'] } }
+      let(:work4_attrs) { { id: 'work_4', isPartOf_ssim: 'admin_set_3', file_set_ids_ssim: ['file_8'] } }
+
+      it "returns rows with document in the first column, count of works in second column and count of files in the third column" do
+        expect(subject).to eq [struct.new(admin_sets[0], 1, 3), struct.new(admin_sets[1], 2, 3), struct.new(admin_sets[2], 1, 1)]
+      end
+    end
+
+    context "when there are no files in the admin set" do
+      let(:work1_attrs) { { id: 'work_1', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: [] } }
+      let(:work2_attrs) { { id: 'work_2', isPartOf_ssim: 'admin_set_2', file_set_ids_ssim: [] } }
+      let(:work3_attrs) { { id: 'work_3', isPartOf_ssim: 'admin_set_2', file_set_ids_ssim: [] } }
+
+      it "returns rows with document in the first column, count of works in second column and count of no files in the third column" do
+        expect(subject).to eq [struct.new(admin_sets[0], 1, 0), struct.new(admin_sets[1], 2, 0), struct.new(admin_sets[2], 0, 0)]
+      end
+    end
+
+    context "when there are more than 10 works in the admin set" do
+      let(:work1_attrs) { { id: 'work_1', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_1'] } }
+      let(:work2_attrs) { { id: 'work_2', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_2'] } }
+      let(:work3_attrs) { { id: 'work_3', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_3'] } }
+      let(:work4_attrs) { { id: 'work_4', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_4'] } }
+      let(:work5_attrs) { { id: 'work_5', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_5'] } }
+      let(:work6_attrs) { { id: 'work_6', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_6'] } }
+      let(:work7_attrs) { { id: 'work_7', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_7'] } }
+      let(:work8_attrs) { { id: 'work_8', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_8'] } }
+      let(:work9_attrs) { { id: 'work_9', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_9'] } }
+      let(:work10_attrs) { { id: 'work_10', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_10'] } }
+      let(:work11_attrs) { { id: 'work_11', isPartOf_ssim: 'admin_set_1', file_set_ids_ssim: ['file_11'] } }
+
+      it "returns rows with document in the first column, count of works in second column and count of files in the third column" do
+        expect(subject).to eq [struct.new(admin_sets[0], 11, 11), struct.new(admin_sets[1], 0, 0), struct.new(admin_sets[2], 0, 0)]
+      end
+    end
+  end
+end

data/spec/services/hyrax/batch_create_failure_service_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe Hyrax::BatchCreateFailureService do
+  let(:depositor) { create(:user) }
+  let(:inbox) { depositor.mailbox.inbox }
+  let(:messages) { ['You did a bad'] }
+
+  describe "#call" do
+    subject { described_class.new(depositor, messages) }
+
+    it "sends failing mail" do
+      subject.call
+      expect(inbox.count).to eq(1)
+      inbox.each do |msg|
+        expect(msg.last_message.subject).to eq('Failing batch create')
+        expect(msg.last_message.body).to eq('The batch create for ' + depositor.user_key + ' failed: ' + messages.first)
+      end
+    end
+  end
+end

data/spec/services/hyrax/batch_create_success_service_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Hyrax::BatchCreateSuccessService do
+  let(:depositor) { create(:user) }
+  let(:inbox) { depositor.mailbox.inbox }
+
+  describe "#call" do
+    subject { described_class.new(depositor) }
+
+    it "sends passing mail" do
+      subject.call
+      expect(inbox.count).to eq(1)
+      inbox.each { |msg| expect(msg.last_message.subject).to eq('Passing batch create') }
+      inbox.each { |msg| expect(msg.last_message.body).to eq('The batch create for ' + depositor.user_key + ' passed.') }
+    end
+  end
+end

data/spec/services/hyrax/change_content_depositor_service_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe Hyrax::ChangeContentDepositorService do
+  let!(:depositor) { create(:user) }
+  let!(:receiver) { create(:user) }
+  let!(:file) do
+    create(:file_set, user: depositor)
+  end
+  let!(:work) do
+    create(:work, title: ['Test work'], user: depositor)
+  end
+
+  before do
+    work.members << file
+    described_class.call(work, receiver, reset)
+  end
+
+  context "by default, when permissions are not reset" do
+    let(:reset) { false }
+
+    it "changes the depositor and records an original depositor" do
+      work.reload
+      expect(work.depositor).to eq receiver.user_key
+      expect(work.proxy_depositor).to eq depositor.user_key
+      expect(work.edit_users).to include(receiver.user_key, depositor.user_key)
+    end
+
+    it "changes the depositor of the child file sets" do
+      file.reload
+      expect(file.depositor).to eq receiver.user_key
+      expect(file.edit_users).to include(receiver.user_key, depositor.user_key)
+    end
+  end
+
+  context "when permissions are reset" do
+    let(:reset) { true }
+
+    it "excludes the depositor from the edit users" do
+      work.reload
+      expect(work.depositor).to eq receiver.user_key
+      expect(work.proxy_depositor).to eq depositor.user_key
+      expect(work.edit_users).to contain_exactly(receiver.user_key)
+    end
+
+    it "changes the depositor of the child file sets" do
+      file.reload
+      expect(file.depositor).to eq receiver.user_key
+      expect(file.edit_users).to include(receiver.user_key, depositor.user_key)
+    end
+  end
+end

data/spec/services/hyrax/collection_member_service_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Hyrax::CollectionMemberService, :clean_repo do
+  let(:user) { create(:user, groups: 'potato') }
+  let!(:ability) { ::Ability.new(user) }
+  let!(:col1) { build(:collection_lw, id: 'col1', user: user, with_solr_document: true) }
+  let!(:col2) { build(:collection_lw, id: 'col2', with_solr_document: true) }
+  let(:colls) { [col1.id, col2.id] }
+  let(:work_attrs) { { id: '123', title_tesim: ['A generic work'], member_of_collection_ids_ssim: colls } }
+  let(:work) { SolrDocument.new(work_attrs) }
+
+  describe "#run" do
+    subject { described_class.run(work, ability) }
+
+    it "returns only authorized parent collections" do
+      expect(subject.count).to eq(1)
+      ids = subject.map { |col| col[:id] }
+      expect(ids).to contain_exactly(col1.id)
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+RSpec.describe Hyrax::CollectionTypes::CreateService do
+  describe '.create_collection_type' do
+    it 'create collection type with default options when no options are received' do # rubocop:disable RSpec/ExampleLength
+      described_class.create_collection_type(machine_id: 'custom_type', title: 'Custom Type')
+      ct = Hyrax::CollectionType.find_by_machine_id('custom_type')
+      expect(ct.machine_id).to eq('custom_type')
+      expect(ct.title).to eq('Custom Type')
+      expect(ct.description).to eq('')
+      expect(ct.badge_color).to eq('#663333')
+      expect(ct).to be_nestable
+      expect(ct).to be_discoverable
+      expect(ct).to be_brandable
+      expect(ct).to be_sharable
+      expect(ct).to be_share_applies_to_new_works
+      expect(ct).to be_allow_multiple_membership
+      expect(ct).not_to be_require_membership
+      expect(ct).not_to be_assigns_workflow
+      expect(ct).not_to be_assigns_visibility
+    end
+
+    it 'creates a collection type for the options received' do
+      options = { description: 'A collection type with options.',
+                  badge_color: '#ffa510',
+                  discoverable: false }
+      described_class.create_collection_type(machine_id: 'custom_type', title: 'Custom Type', options: options)
+      ct = Hyrax::CollectionType.find_by_machine_id('custom_type')
+      expect(ct.description).to include('with options')
+      expect(ct.badge_color).to include('#ffa510')
+      expect(ct).not_to be_discoverable
+    end
+
+    it 'creates collection participants defined in options' do
+      expect do
+        described_class.create_collection_type(machine_id: 'custom_type', title: 'Custom Type')
+      end.to change(Hyrax::CollectionTypeParticipant, :count).by(described_class::DEFAULT_OPTIONS[:participants].count)
+    end
+  end
+
+  describe '.create_admin_set_type' do
+    it 'create the admin set type' do # rubocop:disable RSpec/ExampleLength
+      described_class.create_admin_set_type
+      ct = Hyrax::CollectionType.find_by_machine_id(Hyrax::CollectionType::ADMIN_SET_MACHINE_ID)
+      expect(ct.machine_id).to eq(Hyrax::CollectionType::ADMIN_SET_MACHINE_ID)
+      expect(ct.title).to eq(Hyrax::CollectionType::ADMIN_SET_DEFAULT_TITLE)
+      expect(ct.description).to eq('An aggregation of works that is intended to help with administrative control. Admin Sets provide a way of defining behaviors and policies around a set of works.')
+      expect(ct.badge_color).to eq('#405060')
+      expect(ct).not_to be_nestable
+      expect(ct).not_to be_brandable
+      expect(ct).not_to be_discoverable
+      expect(ct).to be_sharable
+      expect(ct).to be_share_applies_to_new_works
+      expect(ct).not_to be_allow_multiple_membership
+      expect(ct).to be_require_membership
+      expect(ct).to be_assigns_workflow
+      expect(ct).to be_assigns_visibility
+    end
+  end
+
+  describe '.create_user_collection_type' do
+    it 'create the user collection type' do # rubocop:disable RSpec/ExampleLength
+      described_class.create_user_collection_type
+      ct = Hyrax::CollectionType.find_by_machine_id(Hyrax::CollectionType::USER_COLLECTION_MACHINE_ID)
+      expect(ct.machine_id).to eq(Hyrax::CollectionType::USER_COLLECTION_MACHINE_ID)
+      expect(ct.title).to eq(Hyrax::CollectionType::USER_COLLECTION_DEFAULT_TITLE)
+      expect(ct.description).to eq('A User Collection can be created by any user to organize their works.')
+      expect(ct.badge_color).to eq('#705070')
+      expect(ct).to be_nestable
+      expect(ct).to be_brandable
+      expect(ct).to be_discoverable
+      expect(ct).to be_sharable
+      expect(ct).not_to be_share_applies_to_new_works
+      expect(ct).to be_allow_multiple_membership
+      expect(ct).not_to be_require_membership
+      expect(ct).not_to be_assigns_workflow
+      expect(ct).not_to be_assigns_visibility
+    end
+  end
+
+  describe '.add_default_participants' do
+    let(:coltype) { create(:collection_type) }
+
+    it 'adds the default participants to a collection type' do
+      expect(Hyrax::CollectionTypeParticipant).to receive(:create!).exactly(2).times
+      described_class.add_default_participants(coltype.id)
+    end
+  end
+
+  describe '.add_participants' do
+    let(:participants) { [{ agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE, agent_id: 'test_group', access: Hyrax::CollectionTypeParticipant::MANAGE_ACCESS }] }
+    let(:coltype) { create(:collection_type) }
+
+    it 'adds the participants to a collection type' do
+      expect { described_class.add_participants(coltype.id, participants) }
+        .to change { Hyrax::CollectionType.find(coltype.id).collection_type_participants.to_a }
+        .to contain_exactly an_object_having_attributes(**participants.first)
+    end
+
+    context 'when participants are incomplete' do
+      let(:participants) do
+        [{ agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE,
+           agent_id:   'test_group',
+           access:     Hyrax::CollectionTypeParticipant::MANAGE_ACCESS },
+         { agent_type: Hyrax::CollectionTypeParticipant::GROUP_TYPE,
+           agent_id:   'test_group' }]
+      end
+
+      it 'logs and raises an error' do
+        expect(Rails.logger)
+          .to receive(:error)
+          .with a_string_starting_with('Participants not created')
+
+        expect { described_class.add_participants(coltype.id, participants) }
+          .to raise_error(described_class::InvalidParticipantError)
+      end
+
+      it 'does not add participants' do
+        expect do
+          begin
+            described_class.add_participants(coltype.id, participants)
+          rescue described_class::InvalidParticipantError
+            nil
+          end
+        end.not_to change { Hyrax::CollectionType.find(coltype.id).collection_type_participants.to_a }
+      end
+    end
+  end
+end

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

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