hyrax 3.0.0.pre.beta2 → 3.0.0.pre.beta3

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

@@ -30,16 +30,16 @@ RSpec.describe Hyrax::Actors::AttachMembersActor do
 
     context "when the id already exists in the members" do
       it "does nothing" do
-        expect { subject }.not_to change { work.ordered_members.to_a }
+        expect { subject }.not_to change { env.curation_concern.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)
+          expect { subject }.to change { env.curation_concern.ordered_members.to_a }
+          expect(env.curation_concern.ordered_member_ids).not_to include(existing_child_work.id)
+          expect(env.curation_concern.member_ids).not_to include(existing_child_work.id)
         end
       end
     end
@@ -49,18 +49,63 @@ RSpec.describe Hyrax::Actors::AttachMembersActor do
       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
+        let(:another_work) { create(:work, user: depositor) }
+
         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)
+          expect { subject }.to change { env.curation_concern.ordered_members.to_a }
+          expect(env.curation_concern.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 }
+          expect { subject }.not_to change { env.curation_concern.ordered_members.to_a }
+        end
+      end
+    end
+
+    context 'when using a valkyrie resource' do
+      let(:work) { create(:work).valkyrie_resource }
+
+      before { work.member_ids << Valkyrie::ID.new(existing_child_work.id) }
+
+      context "when the _destroy flag is set" do
+        let(:attributes) { HashWithIndifferentAccess.new(work_members_attributes: { '0' => { id: id, _destroy: 'true' } }) }
+
+        it "removes from the members" do
+          expect { middleware.update(env) }
+            .to change { env.curation_concern.member_ids }
+            .from([Valkyrie::ID.new(existing_child_work.id)])
+            .to be_empty
+        end
+      end
+
+      context 'when adding a duplicate member' do
+        it "does nothing" do
+          expect { middleware.update(env) }
+            .not_to change { env.curation_concern.member_ids }
+        end
+      end
+
+      context 'when adding a new member' do
+        let(:another_work) { create(:work, user: depositor) }
+        let(:id) { another_work.id }
+
+        it 'adds successfully' do
+          expect { middleware.update(env) }
+            .to change { env.curation_concern.member_ids }
+            .from([Valkyrie::ID.new(existing_child_work.id)])
+            .to [Valkyrie::ID.new(existing_child_work.id),
+                 Valkyrie::ID.new(another_work.id)]
+        end
+
+        context 'and the ability cannot edit' do
+          let(:another_work) { create(:work) }
+
+          it "does nothing" do
+            expect { middleware.update(env) }
+              .not_to change { env.curation_concern.member_ids }
+          end
         end
       end
     end

data/spec/actors/hyrax/actors/create_with_remote_files_actor_spec.rb

@@ -44,6 +44,20 @@ RSpec.describe Hyrax::Actors::CreateWithRemoteFilesActor do
     end
   end
 
+  context "with source URIs that are remote and contain encoded parameters" do
+    let(:url1) { "https://dl.dropbox.com/fake/file?param1=%28example%29&param2=%5Bexample2%5D" }
+
+    before do
+      allow(::FileSet).to receive(:new).and_call_original
+    end
+
+    it "preserves the encoded parameters in the URIs" do
+      expect(ImportUrlJob).to receive(:perform_later).with(FileSet, Hyrax::Operation, {}).twice
+      expect(actor.create(environment)).to be true
+      expect(::FileSet).to have_received(:new).with(import_url: "https://dl.dropbox.com/fake/file?param1=%28example%29&param2=%5Bexample2%5D", label: "filepicker-demo.txt.txt")
+    end
+  end
+
   context "with source uris that are remote bearing auth headers" do
     let(:remote_files) do
       [{ url: url1,

data/spec/actors/hyrax/actors/create_with_remote_files_ordered_members_actor_spec.rb

@@ -1,5 +1,4 @@
 RSpec.describe Hyrax::Actors::CreateWithRemoteFilesOrderedMembersActor do
-  let(:null_operation) { class_double('Hyrax::Operation').as_null_object }
   let(:terminator) { Hyrax::Actors::Terminator.new }
   let(:actor) { stack.build(terminator) }
   let(:stack) do
@@ -10,48 +9,41 @@ RSpec.describe Hyrax::Actors::CreateWithRemoteFilesOrderedMembersActor do
   let(:user) { create(:user) }
   let(:ability) { Ability.new(user) }
   let(:work) { create(:generic_work, user: user) }
-  let(:urls) { ["https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt", "https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf"] }
-  let(:filenames) { ['filepicker-demo.txt.txt', 'Getting%20Started.pdf'] }
+  let(:url1) { "https://dl.dropbox.com/fake/blah-blah.filepicker-demo.txt.txt" }
+  let(:url2) { "https://dl.dropbox.com/fake/blah-blah.Getting%20Started.pdf" }
 
   let(:remote_files) do
-    urls.collect.with_index do |url, index|
-      { url: url, expires: "2014-03-31T20:37:36.214Z", file_name: filenames[index] }
-    end
+    [{ url: url1,
+       expires: "2014-03-31T20:37:36.214Z",
+       file_name: "filepicker-demo.txt.txt" },
+     { url: url2,
+       expires: "2014-03-31T20:37:36.731Z",
+       file_name: "Getting+Started.pdf" }]
   end
-
   let(:attributes) { { remote_files: remote_files } }
   let(:environment) { Hyrax::Actors::Environment.new(work, ability, attributes) }
 
   before do
-    allow(Hyrax::Operation).to receive(:create!).and_return(null_operation)
     allow(terminator).to receive(:create).and_return(true)
   end
 
   context "with two file_sets" do
-    it "attaches files and passes ordered_members to OrderedMembersActor in correct order" do
-      expect(ImportUrlJob).to receive(:perform_later).with(FileSet, null_operation, {}).twice
-      expect(actor.create(environment)).to be true
-      expect(work.ordered_members.to_a.collect(&:label)).to eq(filenames)
+    let(:remote_files) do
+      [{ url: url1,
+         expires: "2014-03-31T20:37:36.214Z",
+         file_name: "filepicker-demo.txt.txt" },
+       { url: url2,
+         expires: "2014-03-31T20:37:36.731Z",
+         file_name: "Getting+Started.pdf" }]
     end
-  end
-
-  context "with two environments processed by the same actor instance simultaneously" do
-    let(:work2) { create(:generic_work, user: user) }
-    let(:environments) { [environment, Hyrax::Actors::Environment.new(work2, ability, attributes)] }
 
-    # rubocop:disable RSpec/ExampleLength
-    it "attaches the correct FileSets to the correct works in the correct order" do
-      expect(ImportUrlJob).to receive(:perform_later).with(FileSet, null_operation, {}).exactly(4).times
-      threads = environments.collect do |env|
-        Thread.new do
-          Rails.application.reloader.wrap do
-            expect(actor.create(env)).to be true
-            expect(env.curation_concern.ordered_members.to_a.collect(&:label)).to eq(filenames)
-          end
-        end
-      end
-      threads.each(&:join)
+    it "attaches files and passes ordered_members to OrderedMembersActor in correct order" do
+      expect(Hyrax::Actors::OrderedMembersActor).to receive(:new).with([FileSet, FileSet], user).and_return(Hyrax::Actors::OrderedMembersActor)
+      expect(Hyrax::Actors::OrderedMembersActor).to receive(:attach_ordered_members_to_work).with(work)
+      expect(ImportUrlJob).to receive(:perform_later).with(FileSet, Hyrax::Operation, {}).twice
+      expect(actor.create(environment)).to be true
+      expect(actor.ordered_members.first.label).to eq('filepicker-demo.txt.txt')
+      expect(actor.ordered_members.last.label).to eq('Getting+Started.pdf')
     end
-    # rubocop:enable RSpec/ExampleLength
   end
 end

data/spec/actors/hyrax/actors/file_actor_spec.rb

@@ -1,12 +1,15 @@
+require 'wings/services/file_metadata_builder'
+require 'wings/valkyrie/query_service'
+
 RSpec.describe Hyrax::Actors::FileActor do
   include ActionDispatch::TestProcess
   include Hyrax::FactoryHelpers
 
-  let(:user)     { create(:user) }
-  let(:file_set) { create(:file_set) }
-  let(:relation) { :original_file }
-  let(:actor)    { described_class.new(file_set, relation, user) }
-  let(:fixture)  { fixture_file_upload('/world.png', 'image/png') }
+  let(:user)      { create(:user) }
+  let(:file_set)  { create(:file_set) }
+  let(:relation)  { :original_file }
+  let(:actor)     { described_class.new(file_set, relation, user) }
+  let(:fixture)   { fixture_file_upload('/world.png', 'image/png') }
   let(:huf) { Hyrax::UploadedFile.new(user: user, file_set_uri: file_set.uri, file: fixture) }
   let(:io) { JobIoWrapper.new(file_set_id: file_set.id, user: user, uploaded_file: huf) }
   let(:pcdmfile) do
@@ -17,109 +20,222 @@ RSpec.describe Hyrax::Actors::FileActor do
     end
   end
 
-  context 'relation' do
-    let(:relation) { :remastered }
-    let(:file_set) do
-      FileSetWithExtras.create!(attributes_for(:file_set)) do |file|
-        file.apply_depositor_metadata(user.user_key)
+  context 'when using active fedora directly' do
+    context 'relation' do
+      let(:relation) { :remastered }
+      let(:file_set) do
+        FileSetWithExtras.create!(attributes_for(:file_set)) do |file|
+          file.apply_depositor_metadata(user.user_key)
+        end
       end
-    end
 
-    before do
-      class FileSetWithExtras < FileSet
-        directly_contains_one :remastered, through: :files, type: ::RDF::URI('http://pcdm.org/use#IntermediateFile'), class_name: 'Hydra::PCDM::File'
+      before do
+        class FileSetWithExtras < FileSet
+          directly_contains_one :remastered, through: :files, type: ::RDF::URI('http://pcdm.org/use#IntermediateFile'), class_name: 'Hydra::PCDM::File'
+        end
+      end
+      after do
+        Object.send(:remove_const, :FileSetWithExtras)
+      end
+      it 'uses the relation from the actor' do
+        expect(CharacterizeJob).to receive(:perform_later).with(FileSetWithExtras, String, huf.uploader.path)
+        actor.ingest_file(io)
+        expect(file_set.reload.remastered.mime_type).to eq 'image/png'
       end
     end
-    after do
-      Object.send(:remove_const, :FileSetWithExtras)
-    end
-    it 'uses the relation from the actor' do
-      expect(CharacterizeJob).to receive(:perform_later).with(FileSetWithExtras, String, huf.uploader.path)
+
+    it 'uses the provided mime_type' do
+      allow(fixture).to receive(:content_type).and_return('image/gif')
+      expect(CharacterizeJob).to receive(:perform_later).with(FileSet, String, huf.uploader.path)
       actor.ingest_file(io)
-      expect(file_set.reload.remastered.mime_type).to eq 'image/png'
+      expect(file_set.reload.original_file.mime_type).to eq 'image/gif'
     end
-  end
 
-  it 'uses the provided mime_type' do
-    allow(fixture).to receive(:content_type).and_return('image/gif')
-    expect(CharacterizeJob).to receive(:perform_later).with(FileSet, String, huf.uploader.path)
-    actor.ingest_file(io)
-    expect(file_set.reload.original_file.mime_type).to eq 'image/gif'
-  end
+    context 'with two existing versions from different users' do
+      let(:fixture2) { fixture_file_upload('/small_file.txt', 'text/plain') }
+      let(:huf2) { Hyrax::UploadedFile.new(user: user2, file_set_uri: file_set.uri, file: fixture2) }
+      let(:io2) { JobIoWrapper.new(file_set_id: file_set.id, user: user2, uploaded_file: huf2) }
+      let(:user2) { create(:user) }
+      let(:actor2) { described_class.new(file_set, relation, user2) }
+      let(:versions) { file_set.reload.original_file.versions }
 
-  context 'with two existing versions from different users' do
-    let(:fixture2) { fixture_file_upload('/small_file.txt', 'text/plain') }
-    let(:huf2) { Hyrax::UploadedFile.new(user: user2, file_set_uri: file_set.uri, file: fixture2) }
-    let(:io2) { JobIoWrapper.new(file_set_id: file_set.id, user: user2, uploaded_file: huf2) }
-    let(:user2) { create(:user) }
-    let(:actor2) { described_class.new(file_set, relation, user2) }
-    let(:versions) { file_set.reload.original_file.versions }
+      before do
+        allow(Hydra::Works::CharacterizationService).to receive(:run).with(any_args)
+        actor.ingest_file(io)
+        actor2.ingest_file(io2)
+      end
 
-    before do
-      allow(Hydra::Works::CharacterizationService).to receive(:run).with(any_args)
-      actor.ingest_file(io)
-      actor2.ingest_file(io2)
+      it 'has two versions' do
+        expect(versions.all.count).to eq 2
+        # the current version
+        expect(Hyrax::VersioningService.latest_version_of(file_set.reload.original_file).label).to eq 'version2'
+        expect(file_set.original_file.mime_type).to eq 'text/plain'
+        expect(file_set.original_file.original_name).to eq 'small_file.txt'
+        expect(file_set.original_file.content).to eq fixture2.open.read
+        # the user for each version
+        expect(Hyrax::VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq [user.user_key]
+        expect(Hyrax::VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [user2.user_key]
+      end
     end
 
-    it 'has two versions' do
-      expect(versions.all.count).to eq 2
-      # the current version
-      expect(Hyrax::VersioningService.latest_version_of(file_set.reload.original_file).label).to eq 'version2'
-      expect(file_set.original_file.mime_type).to eq 'text/plain'
-      expect(file_set.original_file.original_name).to eq 'small_file.txt'
-      expect(file_set.original_file.content).to eq fixture2.open.read
-      # the user for each version
-      expect(Hyrax::VersionCommitter.where(version_id: versions.first.uri).pluck(:committer_login)).to eq [user.user_key]
-      expect(Hyrax::VersionCommitter.where(version_id: versions.last.uri).pluck(:committer_login)).to eq [user2.user_key]
+    describe '#ingest_file' do
+      before do
+        expect(Hydra::Works::AddFileToFileSet).to receive(:call).with(file_set, io, relation, versioning: false)
+      end
+      it 'when the file is available' do
+        allow(file_set).to receive(:save).and_return(true)
+        allow(file_set).to receive(relation).and_return(pcdmfile)
+        expect(Hyrax::VersioningService).to receive(:create).with(pcdmfile, user)
+        expect(CharacterizeJob).to receive(:perform_later).with(FileSet, pcdmfile.id, huf.uploader.path)
+        actor.ingest_file(io)
+      end
+      it 'returns false when save fails' do
+        allow(file_set).to receive(:save).and_return(false)
+        expect(actor.ingest_file(io)).to be_falsey
+      end
     end
-  end
 
-  describe '#ingest_file' do
-    before do
-      expect(Hydra::Works::AddFileToFileSet).to receive(:call).with(file_set, io, relation, versioning: false)
-    end
-    it 'when the file is available' do
-      allow(file_set).to receive(:save).and_return(true)
-      allow(file_set).to receive(relation).and_return(pcdmfile)
-      expect(Hyrax::VersioningService).to receive(:create).with(pcdmfile, user)
-      expect(CharacterizeJob).to receive(:perform_later).with(FileSet, pcdmfile.id, huf.uploader.path)
-      actor.ingest_file(io)
-    end
-    it 'returns false when save fails' do
-      allow(file_set).to receive(:save).and_return(false)
-      expect(actor.ingest_file(io)).to be_falsey
+    describe '#revert_to' do
+      let(:revision_id) { 'asdf1234' }
+
+      before do
+        allow(pcdmfile).to receive(:restore_version).with(revision_id)
+        allow(file_set).to receive(relation).and_return(pcdmfile)
+        expect(Hyrax::VersioningService).to receive(:create).with(pcdmfile, user)
+        expect(CharacterizeJob).to receive(:perform_later).with(file_set, pcdmfile.id)
+      end
+
+      it 'reverts to a previous version of a file' do
+        expect(file_set).not_to receive(:remastered)
+        expect(actor.relation).to eq(:original_file)
+        actor.revert_to(revision_id)
+      end
+
+      describe 'for a different relation' do
+        let(:relation) { :remastered }
+
+        it 'reverts to a previous version of a file' do
+          expect(actor.relation).to eq(:remastered)
+          actor.revert_to(revision_id)
+        end
+        it 'does not rely on the default relation' do
+          pending "Hydra::Works::VirusCheck must support other relations: https://github.com/samvera/hyrax/issues/1187"
+          expect(actor.relation).to eq(:remastered)
+          expect(file_set).not_to receive(:original_file)
+          actor.revert_to(revision_id)
+        end
+      end
     end
   end
 
-  describe '#revert_to' do
-    let(:revision_id) { 'asdf1234' }
+  context 'when using valkyrie' do
+    let(:user)     { create(:user) }
+    let(:file_set) { create(:file_set) }
+    let(:relation) { Valkyrie::Vocab::PCDMUse.OriginalFile }
+    let(:actor)    { described_class.new(file_set, relation, user, use_valkyrie: true) }
+    let(:fixture)  { fixture_file_upload('/world.png', 'image/png') }
+    let(:huf) { Hyrax::UploadedFile.new(user: user, file: fixture) }
+    let(:io) { JobIoWrapper.new(file_set_id: file_set.id, user: user, uploaded_file: huf, path: huf.uploader.path) }
+    let(:storage_adapter) { Hyrax.storage_adapter }
+    let(:metadata_adapter) { Hyrax.metadata_adapter }
+    let(:persister) { metadata_adapter.persister }
+    let(:query_service) { Wings::Valkyrie::QueryService.new(adapter: metadata_adapter) }
+    let(:file_metadata) do
+      metadata_builder = Wings::FileMetadataBuilder.new(storage_adapter: storage_adapter, persister: persister)
+      file_metadata = Hyrax::FileMetadata.for(file: fixture)
+      metadata_builder.create(file: fixture, file_metadata: file_metadata, file_set: file_set)
+    end
+
+    context 'relation' do
+      let(:relation) { RDF::URI.new("http://pcdm.org/use#remastered") }
+
+      it 'uses the relation from the actor' do
+        pending 'implementation of Wings::Valkyrie::Persister #save_file_metadata'
+        expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user)
+        expect(CharacterizeJob).to receive(:perform_later)
+        saved_metadata = actor.ingest_file(io)
+        reloaded = query_service.find_by(id: file_set.id)
+        expect(reloaded.member_by(use: relation).id).to eq saved_metadata.id
+      end
+
+      context 'when relation is a string' do
+        let(:relation) { 'thumbnail_file' }
 
-    before do
-      allow(pcdmfile).to receive(:restore_version).with(revision_id)
-      allow(file_set).to receive(relation).and_return(pcdmfile)
-      expect(Hyrax::VersioningService).to receive(:create).with(pcdmfile, user)
-      expect(CharacterizeJob).to receive(:perform_later).with(file_set, pcdmfile.id)
+        it 'converts relation to URI before using the relation from the actor' do
+          pending 'implementation of Wings::Valkyrie::Persister #save_file_metadata'
+          expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user)
+          expect(CharacterizeJob).to receive(:perform_later)
+          saved_metadata = actor.ingest_file(io)
+          reloaded = query_service.find_by(id: file_set.id)
+          expect(reloaded.member_by(use: relation).id).to eq saved_metadata.id
+        end
+      end
     end
 
-    it 'reverts to a previous version of a file' do
-      expect(file_set).not_to receive(:remastered)
-      expect(actor.relation).to eq(:original_file)
-      actor.revert_to(revision_id)
+    xit 'uses the provided mime_type' do
+      pending 'implementation of Wings::Valkyrie::Persister #save_file_metadata'
+      allow(fixture).to receive(:content_type).and_return('image/gif')
+      expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user)
+      expect(CharacterizeJob).to receive(:perform_later)
+      saved_metadata = actor.ingest_file(io)
+      expect(saved_metadata.mime_type).to eq ['image/gif']
     end
 
-    describe 'for a different relation' do
-      let(:relation) { :remastered }
+    context 'with two existing versions from different users' do
+      let(:fixture2) { fixture_file_upload('/small_file.txt', 'text/plain') }
+      let(:huf2) { Hyrax::UploadedFile.new(user: user2, file: fixture2) }
+      let(:io2) { JobIoWrapper.new(file_set_id: file_set.id, user: user2, uploaded_file: huf2, path: huf2.uploader.path) }
+      let(:user2) { create(:user) }
+      let(:actor2) { described_class.new(file_set, relation, user2) }
+      let(:adapter) { Hyrax.metadata_adapter }
+      let(:query_service) { Wings::Valkyrie::QueryService.new(adapter: adapter) }
+      let(:versions) do
+        reloaded = query_service.find_by(id: file_set.id)
+        reloaded.original_file.versions
+      end
 
-      it 'reverts to a previous version of a file' do
-        expect(actor.relation).to eq(:remastered)
-        actor.revert_to(revision_id)
+      before do
+        # TODO: WINGS - When #ingest_file works, these should be uncommented.
+        # expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user)
+        # expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user2)
+        # expect(CharacterizeJob).to receive(:perform_later)
+        allow(CharacterizeJob).to receive(:perform_later)
+        actor.ingest_file(io)
+        actor2.ingest_file(io2)
       end
-      it 'does not rely on the default relation' do
-        pending "Hydra::Works::VirusCheck must support other relations: https://github.com/samvera/hyrax/issues/1187"
-        expect(actor.relation).to eq(:remastered)
-        expect(file_set).not_to receive(:original_file)
-        actor.revert_to(revision_id)
+
+      it 'has two versions' do
+        pending 'implementation of Wings::Valkyrie::Persister #save_file_metadata'
+        expect(versions.count).to eq 2
+        # the current version
+        reloaded = query_service.find_by(id: file_set.id)
+        expect(Hyrax::VersioningService.latest_version_of(reloaded.original_file).label).to eq ['version2']
+        expect(file_set.original_file.mime_type).to eq ['text/plain']
+        expect(file_set.original_file.original_filename).to eq ['small_file.txt']
+        expect(file_set.original_file.file.read).to eq fixture2.open.read
+        # the user for each versioe
+        expect(Hyrax::VersionCommitter.where(version_id: versions.first.id.to_s).pluck(:committer_login)).to eq [user.user_key]
+        expect(Hyrax::VersionCommitter.where(version_id: versions.last.id.to_s).pluck(:committer_login)).to eq [user2.user_key]
+      end
+    end
+
+    describe '#ingest_file' do
+      it 'when the file is available' do
+        pending 'implementation of Wings::Valkyrie::Persister #save_file_metadata'
+        expect(Hyrax::VersioningService).to receive(:create).with(Hyrax::FileMetadata, user)
+        expect(CharacterizeJob).to receive(:perform_later)
+        actor.ingest_file(io)
+        reloaded = query_service.find_by(id: file_set.id)
+        expect(reloaded.member_by(use: relation)).not_to be_nil
+      end
+      # rubocop:disable RSpec/AnyInstance
+      it 'returns false when save fails' do
+        expect(Hyrax::VersioningService).not_to receive(:create).with(Hyrax::FileMetadata, user)
+        expect(CharacterizeJob).not_to receive(:perform_later)
+        allow_any_instance_of(Wings::FileMetadataBuilder).to receive(:create).and_raise(StandardError)
+        expect(actor.ingest_file(io)).to be_falsey
       end
+      # rubocop:enable RSpec/AnyInstance
     end
   end
 end