hyrax 1.1.1 → 2.0.0.beta1

data/spec/actors/hyrax/actors/file_set_actor_spec.rb

@@ -1,34 +1,50 @@
-require 'spec_helper'
 require 'redlock'
 
-describe Hyrax::Actors::FileSetActor do
+RSpec.describe Hyrax::Actors::FileSetActor do
   include ActionDispatch::TestProcess
 
-  let(:user)           { create(:user) }
-  let(:uploaded_file)  { fixture_file_upload('/world.png', 'image/png') }
-  let(:local_file)     { File.open(File.join(fixture_path, 'world.png')) }
-  let(:file_set)       { create(:file_set, content: local_file) }
-  let(:actor)          { described_class.new(file_set, user) }
-  let(:ingest_options) { { mime_type: 'image/png', relation: 'original_file', filename: 'world.png' } }
+  let(:user)          { create(:user) }
+  let(:file_path)     { File.join(fixture_path, 'world.png') }
+  let(:file)          { fixture_file_upload(file_path, 'image/png') } # we will override for the different types of File objects
+  let(:local_file)    { File.open(file_path) }
+  let(:file_set)      { create(:file_set, content: local_file) }
+  let(:actor)         { described_class.new(file_set, user) }
+  let(:relation)      { :original_file }
+  let(:file_actor)    { Hyrax::Actors::FileActor.new(file_set, relation, user) }
+
+  before { allow(CharacterizeJob).to receive(:perform_later) } # not testing that
+
+  describe 'private' do
+    let(:file_set) { build(:file_set) } # avoid 130+ LDP requests
+
+    describe '#assign_visibility?' do
+      let(:viz) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+
+      it 'without params, returns false' do
+        expect(actor.send(:assign_visibility?)).to eq false
+      end
+      it 'with string-keyed or symbol-keyed visibility, returns true' do
+        expect(actor.send(:assign_visibility?, visibility: viz)).to eq true
+        expect(actor.send(:assign_visibility?, 'visibility' => viz)).to eq true
+      end
+    end
+  end
 
   describe 'creating metadata, content and attaching to a work' do
-    let(:upload_set_id) { nil }
-    let(:work) { nil }
-    subject { file_set.reload }
+    let(:work) { create(:generic_work) }
     let(:date_today) { DateTime.current }
 
+    subject { file_set.reload }
+
     before do
       allow(DateTime).to receive(:current).and_return(date_today)
-      expect(IngestFileJob).to receive(:perform_later).with(file_set, /world\.png/, user, ingest_options)
       allow(actor).to receive(:acquire_lock_for).and_yield
       actor.create_metadata
-      actor.create_content(uploaded_file)
-      actor.attach_file_to_work(work)
+      actor.create_content(file)
+      actor.attach_to_work(work)
     end
 
     context 'when a work is provided' do
-      let(:work) { create(:generic_work) }
-
       it 'adds the FileSet to the parent work' do
         expect(subject.parents).to eq [work]
         expect(work.reload.file_sets).to include(subject)
@@ -46,36 +62,28 @@ describe Hyrax::Actors::FileSetActor do
     end
   end
 
-  describe "#attach_file_to_work" do
-    let(:work) { create(:public_generic_work) }
-
-    it 'copies visibility from the parent' do
-      allow(actor).to receive(:acquire_lock_for).and_yield
-      actor.attach_file_to_work(work)
-      saved_file = file_set.reload
-      expect(saved_file.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+  describe '#create_content' do
+    before do
+      expect(JobIoWrapper).to receive(:create_with_varied_file_handling!).with(any_args).and_return(JobIoWrapper.new)
+      expect(IngestJob).to receive(:perform_later).with(JobIoWrapper)
     end
-  end
 
-  describe '#create_content' do
-    it 'calls ingest file job' do
-      expect(IngestFileJob).to receive(:perform_later).with(file_set, /world\.png/, user, ingest_options)
-      actor.create_content(uploaded_file)
+    it 'calls ingest_file' do
+      actor.create_content(file)
     end
 
     context 'when an alternative relationship is specified' do
-      let(:ingest_options) { { mime_type: 'image/png', relation: 'remastered', filename: 'world.png' } }
-      it 'calls ingest file job' do
-        expect(IngestFileJob).to receive(:perform_later).with(file_set, /world\.png/, user, ingest_options)
-        actor.create_content(uploaded_file, 'remastered')
+      let(:relation) { :remastered }
+
+      it 'calls ingest_file' do
+        actor.create_content(file, :remastered)
       end
     end
 
     context 'using ::File' do
-      before do
-        allow(IngestFileJob).to receive(:perform_later)
-        actor.create_content(local_file)
-      end
+      let(:file) { local_file }
+
+      before { actor.create_content(local_file) }
 
       it 'sets the label and title' do
         expect(file_set.label).to eq(File.basename(local_file))
@@ -88,21 +96,15 @@ describe Hyrax::Actors::FileSetActor do
     end
 
     context 'when file_set.title is empty and file_set.label is not' do
-      let(:file)       { 'world.png' }
-      let(:long_name)  do
-        'an absurdly long title that goes on way to long and ' \
-                         'messes up the display of the page which should not need ' \
-                         'to be this big in order to show this impossibly long, ' \
-                         'long, long, oh so long string'
+      let(:long_name) do
+        'an absurdly long title that goes on way to long and messes up the display of the page which should not need ' \
+          'to be this big in order to show this impossibly long, long, long, oh so long string'
       end
       let(:short_name) { 'Nice Short Name' }
-      let(:actor)      { described_class.new(file_set, user) }
 
       before do
-        allow(IngestFileJob).to receive(:perform_later)
         allow(file_set).to receive(:label).and_return(short_name)
-        # TODO: we should allow/expect call to IngestJob
-        actor.create_content(fixture_file_upload(file))
+        actor.create_content(file)
       end
 
       subject { file_set.title }
@@ -111,23 +113,22 @@ describe Hyrax::Actors::FileSetActor do
     end
 
     context 'when a label is already specified' do
-      let(:file)     { 'world.png' }
-      let(:label)    { 'test_file.png' }
-      let(:file_set_with_label) do
+      let(:label) { 'test_file.png' }
+      let(:file_set) do
         FileSet.new do |f|
           f.apply_depositor_metadata(user.user_key)
           f.label = label
         end
       end
-      let(:actor) { described_class.new(file_set_with_label, user) }
+      let(:actor) { described_class.new(file_set, user) }
 
       before do
-        allow(IngestFileJob).to receive(:perform_later)
-        actor.create_content(fixture_file_upload(file))
+        allow(IngestJob).to receive(:perform_later).with(JobIoWrapper)
+        actor.create_content(file)
       end
 
       it "retains the object's original label" do
-        expect(file_set_with_label.label).to eql(label)
+        expect(file_set.label).to eql(label)
       end
     end
   end
@@ -140,26 +141,16 @@ describe Hyrax::Actors::FileSetActor do
   end
 
   describe "#update_content" do
-    let(:relation) { 'original_file' }
-    let(:file_actor) { Hyrax::Actors::FileActor.new(file_set, relation, user) }
-    before do
-      allow(actor).to receive(:build_file_actor).with(relation).and_return(file_actor)
-    end
-    it 'calls ingest_file' do
-      expect(file_actor).to receive(:ingest_file).with(local_file, true)
-      actor.update_content(local_file)
+    it 'calls ingest_file and returns queued job' do
+      expect(IngestJob).to receive(:perform_later).with(any_args).and_return(IngestJob.new)
+      expect(actor.update_content(local_file)).to be_a(IngestJob)
     end
     it 'runs callbacks' do
-      # Do not bother ingesting the file -- test only that the callback is run
-      allow(file_actor).to receive(:ingest_file).with(local_file, true)
-      expect(Hyrax.config.callback).to receive(:run).with(:after_update_content, file_set, user)
+      # Do not bother ingesting the file -- test only the result of callback
+      allow(file_actor).to receive(:ingest_file).with(any_args).and_return(double)
+      expect(ContentNewVersionEventJob).to receive(:perform_later).with(file_set, user)
       actor.update_content(local_file)
     end
-    it "returns true" do
-      # Do not bother ingesting the file -- test only the return value
-      allow(file_actor).to receive(:ingest_file).with(local_file, true)
-      expect(actor.update_content(local_file)).to be true
-    end
   end
 
   describe "#destroy" do
@@ -185,161 +176,97 @@ describe Hyrax::Actors::FileSetActor do
         expect(gw.representative_id).to eq(file_set.id)
         expect(gw.thumbnail_id).to eq(file_set.id)
         expect { actor.destroy }.to change { ActiveFedora::Aggregation::Proxy.count }.by(-1)
-        gw = GenericWork.find(work.id)
+        gw.reload
         expect(gw.representative_id).to be_nil
         expect(gw.thumbnail_id).to be_nil
       end
     end
   end
 
-  describe "#attach_file_to_work" do
-    before do
-      # stub out redis connection
-      client = double('redlock client')
-      allow(client).to receive(:lock).and_yield(true)
-      allow(Redlock::Client).to receive(:new).and_return(client)
-    end
-
-    # The first version of the work has no members.
-    let!(:work_v1) { create(:generic_work) }
-
-    # Create another version of the same work with a member.
-    let!(:work_v2) do
-      work = ActiveFedora::Base.find(work_v1.id)
-      work.ordered_members << create(:file_set)
-      work.save
-      work
-    end
-
-    it "writes to the most up to date version" do
-      actor.attach_file_to_work(work_v1, {})
-      expect(work_v1.members.size).to eq 2
-    end
-  end
-
-  describe "#assign_visibility?" do
-    context "when no params are specified" do
-      it "does not need to assign visibility" do
-        expect(actor.send(:assign_visibility?)).to eq false
-      end
-    end
-
-    context "when file set params with visibility are specified with symbols as keys" do
-      let(:file_set_params) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
-
-      it "does need to assign visibility" do
-        expect(actor.send(:assign_visibility?, file_set_params)).to eq true
-      end
-    end
-
-    context "when file set params with visibility are specified with strings as keys" do
-      let(:file_set_params) { { "visibility" => Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
-
-      it "does need to assign visibility" do
-        expect(actor.send(:assign_visibility?, file_set_params)).to eq true
-      end
-    end
-  end
-
-  describe "#set_representative" do
-    let!(:work) { build(:generic_work, representative: rep) }
-    let!(:file_set) { build(:file_set) }
+  describe "#attach_to_work" do
+    let(:work) { build(:public_generic_work) }
 
     before do
-      actor.send(:set_representative, work, file_set)
+      allow(actor).to receive(:acquire_lock_for).and_yield
     end
 
-    context "when the representative isn't set" do
-      let(:rep) { nil }
-
-      it 'sets the representative' do
-        expect(work.representative).to eq file_set
-      end
+    it 'copies file_set visibility from the parent' do
+      actor.attach_to_work(work)
+      expect(file_set.reload.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
     end
 
-    context 'when the representative is already set' do
-      let(:rep) { build(:file_set, id: '123') }
-
-      it 'keeps the existing representative' do
-        expect(work.representative).to eq rep
+    context 'without representative and thumbnail' do
+      it 'assigns them (with persistence)' do
+        actor.attach_to_work(work)
+        expect(work.representative).to eq(file_set)
+        expect(work.thumbnail).to eq(file_set)
+        expect { work.reload }.not_to change { [work.representative, work.thumbnail] }
       end
     end
-  end
-
-  describe "#set_thumbnail" do
-    let!(:work) { build(:generic_work, thumbnail: thumb) }
-    let!(:file_set) { build(:file_set) }
 
-    before do
-      actor.send(:set_thumbnail, work, file_set)
+    context 'with representative and thumbnail' do
+      it 'does not (re)assign them' do
+        allow(work).to receive(:thumbnail_id).and_return('ab123c78h')
+        allow(work).to receive(:representative_id).and_return('zz365c78h')
+        expect(work).not_to receive(:representative=)
+        expect(work).not_to receive(:thumbnail=)
+        actor.attach_to_work(work)
+      end
     end
 
-    context "when the thumbnail isn't set" do
-      let(:thumb) { nil }
+    context 'with multiple versions' do
+      let(:work_v1) { create(:generic_work) } # this version of the work has no members
 
-      it 'sets the thumbnail' do
-        expect(work.thumbnail).to eq file_set
+      before do # another version of the same work is saved with a member
+        work_v2 = ActiveFedora::Base.find(work_v1.id)
+        work_v2.ordered_members << create(:file_set)
+        work_v2.save!
       end
-    end
-
-    context 'when the thumbnail is already set' do
-      let(:thumb) { build(:file_set, id: '123') }
 
-      it 'keeps the existing thumbnail' do
-        expect(work.thumbnail).to eq thumb
+      it "writes to the most up to date version" do
+        actor.attach_to_work(work_v1)
+        expect(work_v1.members.size).to eq 2
       end
     end
   end
 
   describe "#file_actor_class" do
-    context "default" do
-      it "is a FileActor" do
-        expect(actor.file_actor_class).to eq(Hyrax::Actors::FileActor)
-      end
-    end
+    subject { actor.file_actor_class }
 
-    context "overridden" do
-      let(:actor) { CustomFileSetActor.new(file_set, user) }
+    it { is_expected.to eq(Hyrax::Actors::FileActor) }
 
-      before do
-        class CustomFileActor < Hyrax::Actors::FileActor
+    context "overridden" do
+      let(:custom_fs_actor_class) do
+        class ::CustomFileActor < Hyrax::Actors::FileActor
         end
-        class CustomFileSetActor < Hyrax::Actors::FileSetActor
+        Class.new(described_class) do
           def file_actor_class
             CustomFileActor
           end
         end
       end
+      let(:actor) { custom_fs_actor_class.new(file_set, user) }
 
-      after do
-        Object.send(:remove_const, :CustomFileActor)
-        Object.send(:remove_const, :CustomFileSetActor)
-      end
-
-      it "is a custom class" do
-        expect(actor.file_actor_class).to eq(CustomFileActor)
-      end
+      after { Object.send(:remove_const, :CustomFileActor) }
+      it { is_expected.to eq(CustomFileActor) }
     end
   end
 
   describe '#revert_content' do
     let(:file_set) { create(:file_set, user: user) }
     let(:file1)    { "small_file.txt" }
-    let(:file2)    { "hyrax_generic_stub.txt" }
     let(:version1) { "version1" }
+    let(:restored_content) { file_set.reload.original_file }
 
     before do
       original_adapter = ActiveJob::Base.queue_adapter
       ActiveJob::Base.queue_adapter = :inline
-      allow(CharacterizeJob).to receive(:perform_later)
       actor.create_content(fixture_file_upload(file1))
-      actor.create_content(fixture_file_upload(file2))
+      actor.create_content(fixture_file_upload('hyrax_generic_stub.txt'))
       ActiveJob::Base.queue_adapter = original_adapter
       actor.file_set.reload
     end
 
-    let(:restored_content) { file_set.reload.original_file }
-
     it "restores the first versions's content and metadata" do
       actor.revert_content(version1)
       expect(restored_content.original_name).to eq file1

data/spec/actors/hyrax/actors/generic_work_actor_spec.rb

@@ -1,12 +1,11 @@
-require 'spec_helper'
 require 'redlock'
 
-describe Hyrax::Actors::GenericWorkActor do
+RSpec.describe Hyrax::Actors::GenericWorkActor do
   include ActionDispatch::TestProcess
-
+  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
   let(:user) { create(:user) }
-  let(:file_path) { File.join(fixture_path, 'image.png') }
-  let(:file) { Rack::Test::UploadedFile.new(file_path, 'image/png', false) }
+  let(:ability) { ::Ability.new(user) }
+  let(:admin_set) { build(:admin_set, with_permission_template: { with_active_workflow: true }) }
   # stub out redis connection
   let(:redlock_client_stub) do
     client = double('redlock client')
@@ -15,24 +14,39 @@ describe Hyrax::Actors::GenericWorkActor do
     client
   end
 
-  subject do
-    Hyrax::CurationConcern.actor(curation_concern, ::Ability.new(user))
-  end
-
-  let(:admin_set) { create(:admin_set, with_permission_template: { with_active_workflow: true }) }
+  subject { Hyrax::CurationConcern.actor }
 
   describe '#create' do
-    let(:curation_concern) { GenericWork.new }
+    let(:curation_concern) { create(:generic_work, user: user) }
     let(:xmas) { DateTime.parse('2014-12-25 11:30').iso8601 }
+    let(:attributes) { {} }
+    let(:file) { fixture_file_upload('/world.png', 'image/png') }
+    let(:uploaded_file) { Hyrax::UploadedFile.create(file: file, user: user) }
+    let(:terminator) { Hyrax::Actors::Terminator.new }
+
+    subject(:middleware) do
+      stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
+        middleware.use Hyrax::Actors::CreateWithFilesActor
+        middleware.use Hyrax::Actors::AddToWorkActor
+        middleware.use Hyrax::Actors::InterpretVisibilityActor
+        middleware.use described_class
+      end
+      stack.build(terminator)
+    end
+
+    before do
+      allow(terminator).to receive(:create).and_return(true)
+    end
 
     context 'failure' do
       before do
-        allow(subject).to receive(:attach_files).and_return(true)
+        allow(middleware).to receive(:attach_files).and_return(true)
       end
 
-      it 'returns false' do
+      # The clean is here because this test depends on the repo not having an AdminSet/PermissionTemplate created yet
+      it 'returns false', :clean_repo do
         expect(curation_concern).to receive(:save).and_return(false)
-        expect(subject.create({})).to be false
+        expect(middleware.create(env)).to be false
       end
     end
 
@@ -40,17 +54,19 @@ describe Hyrax::Actors::GenericWorkActor do
       before do
         redlock_client_stub
       end
+      let(:attributes) { { title: ['Foo Bar'], admin_set_id: admin_set.id } }
 
       it "invokes the after_create_concern callback" do
         allow(CharacterizeJob).to receive(:perform_later).and_return(true)
         expect(Hyrax.config.callback).to receive(:run)
           .with(:after_create_concern, curation_concern, user)
-        subject.create(title: ['Foo Bar'], admin_set_id: admin_set.id)
+        middleware.create(env)
       end
     end
 
     context 'valid attributes' do
       let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+
       before do
         redlock_client_stub
       end
@@ -58,26 +74,26 @@ describe Hyrax::Actors::GenericWorkActor do
       context 'with embargo' do
         context "with attached files" do
           let(:date) { Time.zone.today + 2 }
+          let(:uploaded_file_ids) { [uploaded_file.id] }
           let(:attributes) do
             { title: ['New embargo'], visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
               visibility_during_embargo: 'authenticated', embargo_release_date: date.to_s,
               visibility_after_embargo: 'open', visibility_during_lease: 'open',
               lease_expiration_date: '2014-06-12', visibility_after_lease: 'restricted',
               admin_set_id: admin_set.id,
-              files: [
-                file
-              ],
-              rights: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+              uploaded_files: uploaded_file_ids,
+              license: ['http://creativecommons.org/licenses/by/3.0/us/'] }
           end
 
           it "applies embargo to attached files" do
             allow(CharacterizeJob).to receive(:perform_later).and_return(true)
-            subject.create(attributes)
-            file = curation_concern.file_sets.first
-            expect(file).to be_persisted
-            expect(file.visibility_during_embargo).to eq 'authenticated'
-            expect(file.visibility_after_embargo).to eq 'open'
-            expect(file.visibility).to eq 'authenticated'
+            middleware.create(env)
+            curation_concern.reload
+            file_set = curation_concern.file_sets.first
+            expect(file_set).to be_persisted
+            expect(file_set.visibility_during_embargo).to eq 'authenticated'
+            expect(file_set.visibility_after_embargo).to eq 'open'
+            expect(file_set.visibility).to eq 'authenticated'
           end
         end
       end
@@ -85,31 +101,33 @@ describe Hyrax::Actors::GenericWorkActor do
       context 'with in_work_ids' do
         let(:parent) { create(:generic_work, user: user) }
         let(:attributes) do
-          FactoryBot.attributes_for(:generic_work, visibility: visibility, admin_set_id: admin_set.id).merge(
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility, admin_set_id: admin_set.id).merge(
             in_works_ids: [parent.id]
           )
         end
+
         it "attaches the parent" do
           allow_any_instance_of(Hyrax::Actors::AddToWorkActor).to receive(:can_edit_both_works?).and_return(true)
-          expect(subject.create(attributes)).to be true
-          expect(curation_concern.in_works).to eq [parent]
+          expect(middleware.create(env)).to be true
+          expect(curation_concern.reload.in_works).to eq [parent]
         end
         it "does not attach the parent" do
           allow_any_instance_of(Hyrax::Actors::AddToWorkActor).to receive(:can_edit_both_works?).and_return(false)
-          expect(subject.create(attributes)).to be false
-          expect(curation_concern.in_works).to eq []
+          expect(middleware.create(env)).to be false
+          expect(curation_concern.reload.in_works).to eq []
         end
       end
 
       context 'with a file' do
         let(:attributes) do
-          FactoryBot.attributes_for(:generic_work, admin_set_id: admin_set.id, visibility: visibility).tap do |a|
-            a[:files] = file
+          FactoryGirl.attributes_for(:generic_work, admin_set_id: admin_set.id, visibility: visibility).tap do |a|
+            a[:uploaded_files] = [uploaded_file.id]
           end
         end
 
         context 'authenticated visibility' do
           let(:file_actor) { double }
+
           before do
             allow(Hyrax::TimeService).to receive(:time_in_utc) { xmas }
             allow(Hyrax::Actors::FileActor).to receive(:new).and_return(file_actor)
@@ -120,7 +138,8 @@ describe Hyrax::Actors::GenericWorkActor do
             expect(Hyrax.config.callback).to receive(:run).with(:after_create_fileset, FileSet, user)
 
             expect(file_actor).to receive(:ingest_file).and_return(true)
-            expect(subject.create(attributes)).to be true
+            expect(middleware.create(env)).to be true
+            curation_concern.reload
             expect(curation_concern).to be_persisted
             expect(curation_concern.date_uploaded).to eq xmas
             expect(curation_concern.date_modified).to eq xmas
@@ -137,9 +156,10 @@ describe Hyrax::Actors::GenericWorkActor do
 
       context 'with multiple files' do
         let(:file_actor) { double }
+        let(:uploaded_file2) { Hyrax::UploadedFile.create(file: file, user: user) }
         let(:attributes) do
-          FactoryBot.attributes_for(:generic_work, admin_set_id: admin_set.id, visibility: visibility).tap do |a|
-            a[:files] = [file, file]
+          FactoryGirl.attributes_for(:generic_work, admin_set_id: admin_set.id, visibility: visibility).tap do |a|
+            a[:uploaded_files] = [uploaded_file.id, uploaded_file2.id]
           end
         end
 
@@ -152,7 +172,8 @@ describe Hyrax::Actors::GenericWorkActor do
           it 'stamps each file with the access rights' do
             expect(file_actor).to receive(:ingest_file).and_return(true).twice
 
-            expect(subject.create(attributes)).to be true
+            expect(middleware.create(env)).to be true
+            curation_concern.reload
             expect(curation_concern).to be_persisted
             expect(curation_concern.date_uploaded).to eq xmas
             expect(curation_concern.date_modified).to eq xmas
@@ -168,11 +189,11 @@ describe Hyrax::Actors::GenericWorkActor do
 
       context 'with a present and a blank title' do
         let(:attributes) do
-          FactoryBot.attributes_for(:generic_work, admin_set_id: admin_set.id, title: ['this is present', ''])
+          FactoryGirl.attributes_for(:generic_work, admin_set_id: admin_set.id, title: ['this is present', ''])
         end
 
         it 'stamps each link with the access rights' do
-          expect(subject.create(attributes)).to be true
+          expect(middleware.create(env)).to be true
           expect(curation_concern).to be_persisted
           expect(curation_concern.title).to eq ['this is present']
         end
@@ -188,15 +209,17 @@ describe Hyrax::Actors::GenericWorkActor do
 
       it 'returns false' do
         expect(curation_concern).to receive(:save).and_return(false)
-        expect(subject.update(attributes)).to be false
+        expect(subject.update(env)).to be false
       end
     end
 
     context 'success' do
+      let(:attributes) { { title: ['Other Title'] } }
+
       it "invokes the after_update_metadata callback" do
         expect(Hyrax.config.callback).to receive(:run)
           .with(:after_update_metadata, curation_concern, user)
-        subject.update(title: ['Other Title'])
+        subject.update(env)
       end
     end
 
@@ -204,27 +227,30 @@ describe Hyrax::Actors::GenericWorkActor do
       let(:parent) { create(:generic_work, user: user) }
       let(:old_parent) { create(:generic_work, user: user) }
       let(:attributes) do
-        FactoryBot.attributes_for(:generic_work).merge(
+        FactoryGirl.attributes_for(:generic_work).merge(
           in_works_ids: [parent.id]
         )
       end
+
       before do
         old_parent.ordered_members << curation_concern
         old_parent.save!
       end
       it "attaches the parent" do
-        expect(subject.update(attributes)).to be true
+        expect(subject.update(env)).to be true
         expect(curation_concern.in_works).to eq [parent]
         expect(old_parent.reload.members).to eq []
       end
     end
+
     context 'without in_works_ids' do
-      let(:old_parent) { FactoryBot.create(:generic_work) }
+      let(:old_parent) { FactoryGirl.create(:generic_work) }
       let(:attributes) do
-        FactoryBot.attributes_for(:generic_work).merge(
+        FactoryGirl.attributes_for(:generic_work).merge(
           in_works_ids: []
         )
       end
+
       before do
         curation_concern.apply_depositor_metadata(user.user_key)
         curation_concern.save!
@@ -233,18 +259,20 @@ describe Hyrax::Actors::GenericWorkActor do
       end
       it "removes the old parent" do
         allow(curation_concern).to receive(:depositor).and_return(old_parent.depositor)
-        expect(subject.update(attributes)).to be true
+        expect(subject.update(env)).to be true
         expect(curation_concern.in_works).to eq []
         expect(old_parent.reload.members).to eq []
       end
     end
+
     context 'with nil in_works_ids' do
-      let(:parent) { FactoryBot.create(:generic_work) }
+      let(:parent) { FactoryGirl.create(:generic_work) }
       let(:attributes) do
-        FactoryBot.attributes_for(:generic_work).merge(
+        FactoryGirl.attributes_for(:generic_work).merge(
           in_works_ids: nil
         )
       end
+
       before do
         curation_concern.apply_depositor_metadata(user.user_key)
         curation_concern.save!
@@ -252,16 +280,18 @@ describe Hyrax::Actors::GenericWorkActor do
         parent.save!
       end
       it "does nothing" do
-        expect(subject.update(attributes)).to be true
+        expect(subject.update(env)).to be true
         expect(curation_concern.in_works).to eq [parent]
       end
     end
+
     context 'adding to collections' do
       let!(:collection1) { create(:collection, user: user) }
       let!(:collection2) { create(:collection, user: user) }
       let(:attributes) do
-        FactoryBot.attributes_for(:generic_work, member_of_collection_ids: [collection2.id])
+        FactoryGirl.attributes_for(:generic_work, member_of_collection_ids: [collection2.id])
       end
+
       before do
         curation_concern.apply_depositor_metadata(user.user_key)
         curation_concern.member_of_collections = [collection1]
@@ -273,7 +303,7 @@ describe Hyrax::Actors::GenericWorkActor do
         expect(curation_concern.member_of_collection_ids).to eq [collection1.id]
         # before running actor.update, the work is in collection1
 
-        expect(subject.update(attributes)).to be true
+        expect(subject.update(env)).to be true
 
         curation_concern.reload
         expect(curation_concern.identifier).to be_blank
@@ -288,11 +318,12 @@ describe Hyrax::Actors::GenericWorkActor do
       let(:file_set2) { create(:file_set) }
       let(:curation_concern) { create(:generic_work, user: user, ordered_members: [file_set1, file_set2], admin_set_id: admin_set.id) }
       let(:attributes) do
-        FactoryBot.attributes_for(:generic_work, ordered_member_ids: [file_set2.id, file_set1.id])
+        FactoryGirl.attributes_for(:generic_work, ordered_member_ids: [file_set2.id, file_set1.id])
       end
+
       it 'updates the order of file sets' do
         expect(curation_concern.ordered_members.to_a).to eq [file_set1, file_set2]
-        expect(subject.update(attributes)).to be true
+        expect(subject.update(env)).to be true
 
         curation_concern.reload
         expect(curation_concern.ordered_members.to_a).to eq [file_set2, file_set1]
@@ -300,12 +331,13 @@ describe Hyrax::Actors::GenericWorkActor do
       ## Is this something we want to support?
       context "when told to stop ordering a file set" do
         let(:attributes) do
-          FactoryBot.attributes_for(:generic_work, ordered_member_ids: [file_set2.id])
+          FactoryGirl.attributes_for(:generic_work, ordered_member_ids: [file_set2.id])
         end
+
         it "works" do
           expect(curation_concern.ordered_members.to_a).to eq [file_set1, file_set2]
 
-          expect(subject.update(attributes)).to be true
+          expect(subject.update(env)).to be true
 
           curation_concern.reload
           expect(curation_concern.ordered_members.to_a).to eq [file_set2]