hyrax 3.0.0.pre.rc1 → 3.0.0.pre.rc2

data/spec/services/hyrax/admin_set_member_service_spec.rb

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

@@ -1,171 +0,0 @@
-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|
-        Hyrax::SolrService.add(obj)
-      end
-      Hyrax::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

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

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

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

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

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

@@ -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