hyrax 2.6.0 → 2.7.0

data/spec/abilities/solr_document_ability_spec.rb

@@ -1,27 +0,0 @@
-require 'cancan/matchers'
-
-# rubocop:disable RSpec/EmptyExampleGroup
-RSpec.describe 'SolrDocumentAbility' do
-  subject { ability }
-
-  let(:ability) { Ability.new(current_user) }
-  let(:user) { create(:user) }
-  let(:current_user) { user }
-
-  context 'with Collection solr doc' do
-    # tested with collection's solr doc in collection_ability_spec.rb
-  end
-
-  context 'with admin_set' do
-    # tested with admin_set's solr doc in admin_set_ability_spec.rb
-  end
-
-  context 'with works' do
-    # TODO: Need tests for works
-  end
-
-  context 'with files' do
-    # TODO: Need tests for files
-  end
-end
-# rubocop:enable RSpec/EmptyExampleGroup

data/spec/actors/hyrax/actors/apply_order_actor_spec.rb

@@ -1,92 +0,0 @@
-RSpec.describe Hyrax::Actors::ApplyOrderActor do
-  let(:curation_concern) { create(:work_with_two_children, user: user) }
-  let(:ability) { ::Ability.new(user) }
-  let(:user) { create(:admin) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-      middleware.use Hyrax::Actors::GenericWorkActor
-    end
-    stack.build(terminator)
-  end
-
-  describe '#update' do
-    context 'with ordered_member_ids that are already associated with the parent' do
-      let(:attributes) { { ordered_member_ids: ["BlahBlah1"] } }
-
-      before do
-        allow(terminator).to receive(:update).with(Hyrax::Actors::Environment).and_return(true)
-        curation_concern.apply_depositor_metadata(user.user_key)
-        curation_concern.save!
-      end
-      it "attaches the parent" do
-        expect(subject.update(env)).to be true
-      end
-    end
-  end
-
-  describe '#update' do
-    let(:user) { create(:admin) }
-    let(:curation_concern) { create(:work_with_one_child, user: user) }
-    let(:child) { GenericWork.new }
-
-    context 'with ordered_members_ids that arent associated with the curation concern yet.' do
-      let(:attributes) { { ordered_member_ids: [child.id] } }
-      let(:root_actor) { double }
-
-      before do
-        allow(terminator).to receive(:update).with(Hyrax::Actors::Environment).and_return(true)
-        # TODO: This can be moved into the Factory
-        child.title = ["Generic Title"]
-        child.apply_depositor_metadata(user.user_key)
-        child.save!
-        curation_concern.apply_depositor_metadata(user.user_key)
-        curation_concern.save!
-      end
-
-      it "attaches the parent" do
-        expect(subject.update(env)).to be true
-      end
-    end
-
-    context 'without an ordered_member_id that was associated with the curation concern' do
-      let(:curation_concern) { create(:work_with_two_children, user: user) }
-      let(:attributes) { { ordered_member_ids: ["BlahBlah2"] } }
-
-      before do
-        allow(terminator).to receive(:update).with(Hyrax::Actors::Environment).and_return(true)
-        child.title = ["Generic Title"]
-        child.apply_depositor_metadata(user.user_key)
-        child.save!
-        curation_concern.apply_depositor_metadata(user.user_key)
-        curation_concern.save!
-      end
-      it "removes the first child" do
-        expect(subject.update(env)).to be true
-        expect(curation_concern.members.size).to eq(1)
-        expect(curation_concern.ordered_member_ids.size).to eq(1)
-      end
-    end
-
-    context 'with ordered_member_ids that include a work owned by a different user' do
-      # set user not a non-admin for this test to ensure the actor disallows adding the child
-      let(:user) { create(:user) }
-      let(:other_user) { create(:user) }
-      let(:child) { create(:generic_work, user: other_user) }
-      let(:attributes) { { ordered_member_ids: [child.id] } }
-
-      before do
-        allow(terminator).to receive(:update).with(Hyrax::Actors::Environment).and_return(true)
-        curation_concern.apply_depositor_metadata(user.user_key)
-        curation_concern.save!
-      end
-
-      it "does not attach the work" do
-        expect(subject.update(env)).to be false
-      end
-    end
-  end
-end

data/spec/actors/hyrax/actors/apply_permission_template_actor_spec.rb

@@ -1,135 +0,0 @@
-RSpec.describe Hyrax::Actors::ApplyPermissionTemplateActor do
-  let(:ability) { ::Ability.new(depositor) }
-  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:depositor) { create(:user) }
-  let(:work) do
-    build(:generic_work,
-          user: depositor,
-          edit_users: ['Kevin'],
-          read_users: ['Taraji'])
-  end
-  let(:attributes) { { source_id: admin_set.id } }
-  let(:admin_set) { create(:admin_set, with_permission_template: true) }
-  let(:as_permission_template) { admin_set.permission_template }
-  let(:collection) { create(:collection, with_permission_template: true) }
-  let(:col_permission_template) { collection.permission_template }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-    end
-    stack.build(terminator)
-  end
-
-  describe "create" do
-    context "when source_id is blank" do
-      let(:attributes) { { admin_set_id: '' } }
-
-      it "returns true" do
-        expect(middleware.create(env)).to be true
-      end
-    end
-
-    context "when admin_set_id only is provided" do
-      let(:attributes) { { admin_set_id: admin_set.id } }
-
-      before do
-        admin_set_access(as_permission_template)
-        allow(terminator).to receive(:create).and_return(true)
-      end
-
-      it "adds the template users to the work" do
-        expect(middleware.create(env)).to be true
-        expect(work.edit_users).to match_array [depositor.user_key, 'Kevin', 'hannah a. smith']
-        expect(work.edit_groups).to match_array ['librarians_as']
-        expect(work.read_users).to match_array ['Taraji', 'gary a. stevens']
-        expect(work.read_groups).to match_array ['readers_as']
-      end
-    end
-
-    context "when admin_set_id and collection_id is provided" do
-      let(:attributes) { { admin_set_id: admin_set.id, collection_id: collection.id } }
-
-      before do
-        admin_set_access(as_permission_template)
-        collection_access(col_permission_template)
-        allow(terminator).to receive(:create).and_return(true)
-      end
-
-      it "adds the template users to the work" do
-        expect(middleware.create(env)).to be true
-        expect(work.edit_users).to match_array [depositor.user_key, 'Kevin', 'hannah a. smith', 'joe conrad']
-        expect(work.edit_groups).to match_array ['librarians_as', 'managers_c']
-        expect(work.read_users).to match_array ['Taraji', 'gary a. stevens', 'carol cassidy']
-        expect(work.read_groups).to match_array ['readers_as', 'viewers_c']
-      end
-    end
-
-    def admin_set_access(permission_template) # rubocop:disable Metrics/MethodLength
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: 'hannah a. smith')
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: 'librarians_as')
-      create(:permission_template_access,
-             :deposit,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: 'mike a. steward')
-      create(:permission_template_access,
-             :deposit,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: 'staff_as')
-      create(:permission_template_access,
-             :view,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: 'gary a. stevens')
-      create(:permission_template_access,
-             :view,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: 'readers_as')
-    end
-
-    def collection_access(permission_template) # rubocop:disable Metrics/MethodLength
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: "joe conrad")
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: "managers_c")
-      create(:permission_template_access,
-             :deposit,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: "donny cartwright")
-      create(:permission_template_access,
-             :deposit,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: "depositors_c")
-      create(:permission_template_access,
-             :view,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: "carol cassidy")
-      create(:permission_template_access,
-             :view,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: "viewers_c")
-    end
-  end
-end

data/spec/actors/hyrax/actors/attach_members_actor_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe Hyrax::Actors::AttachMembersActor do
-  let(:ability) { ::Ability.new(depositor) }
-  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:depositor) { create(:user) }
-  let(:work) { create(:work) }
-  let(:attributes) { HashWithIndifferentAccess.new(work_members_attributes: { '0' => { id: id } }) }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-    end
-    stack.build(terminator)
-  end
-
-  describe "#update" do
-    subject { middleware.update(env) }
-
-    before do
-      work.ordered_members << existing_child_work
-    end
-    let(:existing_child_work) { create(:work) }
-    let(:id) { existing_child_work.id }
-
-    context "without useful attributes" do
-      let(:attributes) { {} }
-
-      it { is_expected.to be true }
-    end
-
-    context "when the id already exists in the members" do
-      it "does nothing" do
-        expect { subject }.not_to change { work.ordered_members.to_a }
-      end
-
-      context "and the _destroy flag is set" do
-        let(:attributes) { HashWithIndifferentAccess.new(work_members_attributes: { '0' => { id: id, _destroy: 'true' } }) }
-
-        it "removes from the member and the ordered members" do
-          expect { subject }.to change { work.ordered_members.to_a }
-          expect(work.ordered_member_ids).not_to include(existing_child_work.id)
-          expect(work.member_ids).not_to include(existing_child_work.id)
-        end
-      end
-    end
-
-    context "when the id does not exist in the members" do
-      let(:another_work) { create(:work) }
-      let(:id) { another_work.id }
-
-      context "and I can edit that object" do
-        before do
-          allow(ability).to receive(:can?).with(:edit, GenericWork).and_return(true)
-        end
-        it "is added to the ordered members" do
-          expect { subject }.to change { work.ordered_members.to_a }
-          expect(work.ordered_member_ids).to include(existing_child_work.id, another_work.id)
-        end
-      end
-
-      context "and I can not edit that object" do
-        it "does nothing" do
-          expect { subject }.not_to change { work.ordered_members.to_a }
-        end
-      end
-    end
-  end
-end

data/spec/actors/hyrax/actors/cleanup_file_sets_actor_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe Hyrax::Actors::CleanupFileSetsActor do
-  let(:ability) { ::Ability.new(depositor) }
-  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:depositor) { create(:user) }
-  let(:attributes) { {} }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-    end
-    stack.build(terminator)
-  end
-
-  describe "#destroy" do
-    subject { middleware.destroy(env) }
-
-    let!(:work) { create(:work_with_one_file) }
-
-    it 'removes all  file sets' do
-      expect { middleware.destroy(env) }.to change { FileSet.count }.by(-1)
-    end
-  end
-end

data/spec/actors/hyrax/actors/cleanup_trophies_actor_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe Hyrax::Actors::CleanupTrophiesActor do
-  let(:ability) { ::Ability.new(depositor) }
-  let(:env) { Hyrax::Actors::Environment.new(work, ability, attributes) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:depositor) { create(:user) }
-  let(:work) { create(:work) }
-  let(:attributes) { {} }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-    end
-    stack.build(terminator)
-  end
-
-  describe "#destroy" do
-    subject { middleware.destroy(env) }
-
-    let!(:trophy) { Trophy.create(user_id: depositor.id, work_id: work.id) }
-
-    it 'removes all the trophies' do
-      expect { middleware.destroy(env) }.to change { Trophy.where(work_id: work.id).count }.from(1).to(0)
-    end
-  end
-end

data/spec/actors/hyrax/actors/collections_membership_actor_spec.rb

@@ -1,364 +0,0 @@
-RSpec.describe Hyrax::Actors::CollectionsMembershipActor do
-  let(:user) { create(:user) }
-  let(:ability) { ::Ability.new(user) }
-  let(:curation_concern) { build(:work, user: user) }
-  let(:attributes) { {} }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-      middleware.use RemoveCollectionActor
-      middleware.use Hyrax::Actors::GenericWorkActor
-    end
-    stack.build(terminator)
-  end
-
-  describe 'the next actor' do
-    let(:collection) { build(:collection_lw, with_permission_template: true) }
-    let(:attributes) do
-      {
-        member_of_collections_attributes: { '0' => { id: '123' } },
-        title: ['test']
-      }
-    end
-
-    before do
-      allow(Collection).to receive(:find).with('123').and_return(collection)
-      allow(curation_concern).to receive(:member_of_collections=)
-    end
-
-    it 'does not receive the member_of_collections_attributes' do
-      expect(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
-        expect(k.attributes).to eq("title" => ["test"])
-      end
-      subject.create(env)
-    end
-  end
-
-  describe 'create' do
-    let(:collection) { create(:collection, collection_type_settings: [:discoverable], user: user, create_access: true) }
-    let(:attributes) do
-      {
-        member_of_collections_attributes: { '0' => { id: collection.id } },
-        title: ['test']
-      }
-    end
-
-    it 'adds it to the collection' do
-      expect(subject.create(env)).to be true
-      expect(collection.reload.member_objects).to eq [curation_concern]
-    end
-
-    context 'when multiple membership checker returns a non-nil value' do
-      before do
-        allow(Hyrax::MultipleMembershipChecker).to receive(:new).and_return(checker)
-        allow(checker).to receive(:check).and_return(error_message)
-      end
-
-      let(:checker) { double('checker') }
-      let(:error_message) { 'Error: foo bar' }
-
-      it 'adds an error and returns false' do
-        expect(env.curation_concern.errors).to receive(:add).with(:collections, error_message)
-        expect(subject.create(env)).to be false
-        expect(curation_concern.member_of_collections).to be_empty
-      end
-    end
-
-    context "when work is in user's own collection and destroy is passed" do
-      let(:collection) { build(:collection_lw, user: user, title: ['A good title'], with_permission_template: true) }
-      let(:attributes) do
-        { member_of_collections_attributes: { '0' => { id: collection.id, _destroy: 'true' } } }
-      end
-
-      before do
-        curation_concern.member_of_collections = [collection]
-        curation_concern.save!
-      end
-
-      it "removes the work from that collection" do
-        expect(subject.create(env)).to be true
-        expect(curation_concern.member_of_collections).to eq []
-      end
-    end
-
-    context "when work is in another user's collection" do
-      let(:other_user) { create(:user) }
-      let(:other_collection) { build(:collection_lw, user: other_user, title: ['A good title'], with_permission_template: true) }
-
-      before do
-        curation_concern.member_of_collections = [other_collection]
-        curation_concern.save!
-      end
-
-      it "doesn't remove the work from the other user's collection" do
-        subject.create(env)
-        expect(subject.create(env)).to be true
-        expect(curation_concern.member_of_collections).to match_array [collection, other_collection]
-      end
-    end
-
-    context 'when passing `member_of_collection_ids`' do
-      let(:attributes) { { member_of_collection_ids: [collection.id], title: ['test'] } }
-
-      it 'adds it to the collection' do
-        skip 'this behavior past its deprecation sunset time and can be removed' if
-          Hyrax::VERSION.split('.').first.to_i >= 3
-
-        expect(subject.create(env)).to be true
-        expect(collection.reload.member_objects).to eq [curation_concern]
-      end
-
-      context 'when it is empty' do
-        let(:attributes) { { member_of_collection_ids: [], title: ['test'] } }
-
-        it 'does not add it to a collection' do
-          skip 'this behavior past its deprecation sunset time and can be removed' if
-            Hyrax::VERSION.split('.').first.to_i >= 3
-
-          expect(subject.create(env)).to be true
-          expect(collection.reload.member_objects).to eq []
-        end
-      end
-
-      context 'when it is an empty string' do
-        let(:attributes) { { member_of_collection_ids: '', title: ['test'] } }
-
-        it 'does not add it to a collection' do
-          skip 'this behavior past its deprecation sunset time and can be removed' if
-            Hyrax::VERSION.split('.').first.to_i >= 3
-
-          expect(subject.create(env)).to be true
-          expect(collection.reload.member_objects).to eq []
-        end
-      end
-
-      context "when work is in user's own collection" do
-        let(:attributes) { { member_of_collection_ids: [] } }
-
-        it "removes the work from that collection" do
-          skip 'this behavior past its deprecation sunset time and can be removed' if
-            Hyrax::VERSION.split('.').first.to_i >= 3
-
-          expect(subject.create(env)).to be true
-          expect(collection.reload.member_objects).to be_empty
-        end
-      end
-
-      describe "when work is in another user's collection" do
-        let(:other_user)    { create(:user) }
-        let(:collection)    { create(:collection, user: other_user, title: ['A good title']) }
-        let(:my_collection) { create(:collection, title: ['My good title']) }
-
-        let(:attributes) { { member_of_collection_ids: [my_collection.id] } }
-
-        before do
-          curation_concern.member_of_collections = [collection]
-          curation_concern.save!
-        end
-
-        it "doesn't remove the work from the other user's collection" do
-          skip 'this behavior past its deprecation sunset time and can be removed' if
-            Hyrax::VERSION.split('.').first.to_i >= 3
-
-          expect(subject.create(env)).to be true
-          expect(curation_concern.member_of_collections)
-            .to contain_exactly(collection, my_collection)
-        end
-      end
-    end
-
-    context "updates env" do
-      let!(:collection_type) { create(:collection_type) }
-      let!(:collection) { create(:collection_lw, collection_type_gid: collection_type.gid, with_permission_template: true) }
-
-      subject(:middleware) do
-        stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-          middleware.use described_class
-        end
-        stack.build(terminator)
-      end
-
-      context "when share applies to works" do
-        before do
-          allow(collection.collection_type).to receive(:share_applies_to_works).and_return(true)
-        end
-
-        context "and only one collection" do
-          let(:attributes) do
-            {
-              member_of_collections_attributes: { '0' => { id: collection.id } },
-              title: ['test']
-            }
-          end
-
-          it "removes member_of_collections_attributes and adds collection_id to env" do
-            expect(env.attributes).to have_key(:member_of_collections_attributes)
-            expect(env.attributes[:member_of_collections_attributes].size).to eq 1
-            expect(subject.create(env)).to be true
-            expect(env.attributes).not_to have_key(:member_of_collections_attributes)
-            expect(env.attributes).to have_key(:collection_id)
-            expect(env.attributes[:collection_id]).to eq collection.id
-          end
-        end
-
-        context "when more than one collection" do
-          let(:collection2) { create(:collection_lw, with_permission_template: true) }
-          let(:attributes) do
-            {
-              member_of_collections_attributes: {
-                '0' => { id: collection.id },
-                '1' => { id: collection2.id }
-              },
-              title: ['test']
-            }
-          end
-
-          it "removes member_of_collections_attributes and does NOT add collection_id" do
-            expect(env.attributes).to have_key(:member_of_collections_attributes)
-            expect(env.attributes[:member_of_collections_attributes].size).to eq 2
-            expect(subject.create(env)).to be true
-            expect(env.attributes).not_to have_key(:member_of_collections_attributes)
-            expect(env.attributes).not_to have_key(:collection_id)
-          end
-        end
-      end
-
-      context "when share does NOT apply to works" do
-        before do
-          allow(collection.collection_type).to receive(:share_applies_to_new_works?).and_return(false)
-          allow(Collection).to receive(:find).with(collection.id).and_return(collection)
-          allow(Collection).to receive(:find).with([collection.id]).and_return([collection])
-        end
-
-        context "and only one collection" do
-          let(:attributes) do
-            {
-              member_of_collections_attributes: { '0' => { id: collection.id } },
-              title: ['test']
-            }
-          end
-
-          it "removes member_of_collection_ids and does NOT add collection_id" do
-            expect(env.attributes).to have_key(:member_of_collections_attributes)
-            expect(env.attributes[:member_of_collections_attributes].size).to eq 1
-            expect(subject.create(env)).to be true
-            expect(env.attributes).not_to have_key(:member_of_collections_attributes)
-            expect(env.attributes).not_to have_key(:collection_id)
-          end
-        end
-      end
-    end
-  end
-
-  context 'when old style env parameter' do
-    describe 'create' do
-      let(:collection) { create(:collection) }
-      let(:attributes) do
-        { member_of_collection_ids: [collection.id], title: ['test'] }
-      end
-
-      it 'adds it to the collection' do
-        expect(subject.create(env)).to be true
-        expect(collection.reload.member_objects).to eq [curation_concern]
-      end
-
-      context 'when multiple membership checker returns a non-nil value' do
-        before do
-          allow(Hyrax::MultipleMembershipChecker).to receive(:new).and_return(checker)
-          allow(checker).to receive(:check).and_return(error_message)
-        end
-
-        let(:checker) { double('checker') }
-        let(:error_message) { 'Error: foo bar' }
-
-        it 'adds an error and returns false' do
-          expect(env.curation_concern.errors).to receive(:add).with(:collections, error_message)
-          expect(subject.create(env)).to be false
-          expect(curation_concern.member_of_collections).to be_empty
-        end
-      end
-
-      context "when work is in user's own collection" do
-        let(:collection) { create(:collection, user: user, title: ['A good title']) }
-        let(:attributes) { { member_of_collection_ids: [] } }
-
-        before do
-          subject.create(Hyrax::Actors::Environment.new(curation_concern, ability,
-                                                        member_of_collection_ids: [collection.id], title: ['test']))
-        end
-
-        it "removes the work from that collection" do
-          expect(subject.create(env)).to be true
-          expect(curation_concern.member_of_collections).to eq []
-        end
-      end
-
-      context "when work is in another user's collection" do
-        let(:other_user) { create(:user) }
-        let(:collection) { create(:collection, user: other_user, title: ['A good title']) }
-
-        it "doesn't remove the work from that collection" do
-          subject.create(env)
-          expect(subject.create(env)).to be true
-          expect(curation_concern.member_of_collections).to eq [collection]
-        end
-      end
-
-      context "updates env" do
-        let(:collection) do
-          create(:collection, collection_type_settings: [:discoverable, :sharable])
-        end
-
-        subject(:middleware) do
-          stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-            middleware.use described_class
-          end
-          stack.build(terminator)
-        end
-
-        context "when only one collection" do
-          let(:attributes) do
-            { member_of_collection_ids: [collection.id], title: ['test'] }
-          end
-
-          it "removes member_of_collection_ids and adds collection_id to env" do
-            expect(env.attributes).to have_key(:member_of_collection_ids)
-            expect(env.attributes[:member_of_collection_ids].size).to eq 1
-            expect(subject.create(env)).to be true
-            expect(env.attributes).not_to have_key(:member_of_collection_ids)
-            expect(env.attributes).to have_key(:collection_id)
-            expect(env.attributes[:collection_id]).to eq collection.id
-          end
-        end
-
-        context "when more than one collection" do
-          let(:collection2) { create(:collection) }
-          let(:attributes) do
-            { member_of_collection_ids: [collection.id, collection2.id], title: ['test'] }
-          end
-
-          it "removes member_of_collection_ids and does NOT add collection_id" do
-            expect(env.attributes).to have_key(:member_of_collection_ids)
-            expect(env.attributes[:member_of_collection_ids].size).to eq 2
-            expect(subject.create(env)).to be true
-            expect(env.attributes).not_to have_key(:member_of_collection_ids)
-            expect(env.attributes).not_to have_key(:collection_id)
-          end
-        end
-      end
-    end
-  end
-
-  class RemoveCollectionActor < Hyrax::Actors::AbstractActor
-    # The collection is normally removed by ApplyPermissionTemplateActor, but this test doesn't setup and call that actor.
-    # So we are faking it here and removing it before the GenericWorkActor is called.  Otherwise, it tries to save a
-    # property named collection_id which doesn't exist in GenericWork.
-    def create(env)
-      env.attributes.delete(:collection_id)
-      next_actor.create(env)
-    end
-  end
-end