hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/jobs/batch_create_job_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe BatchCreateJob do
+  let(:user) { create(:user) }
+  let(:operation) { create(:batch_create_operation, user: user) }
+  let(:child_operation) { double }
+
+  describe "#perform" do
+    let(:file1) { File.open(fixture_path + '/world.png') }
+    let(:file2) { File.open(fixture_path + '/image.jp2') }
+    let(:upload1) { Hyrax::UploadedFile.create(user: user, file: file1) }
+    let(:upload2) { Hyrax::UploadedFile.create(user: user, file: file2) }
+    let(:title) { { upload1.id.to_s => 'File One', upload2.id.to_s => 'File Two' } }
+    let(:resource_types) { { upload1.id.to_s => 'Article', upload2.id.to_s => 'Image' } }
+    let(:metadata) { { keyword: [], model: 'GenericWork' } }
+    let(:uploaded_files) { [upload1.id.to_s, upload2.id.to_s] }
+
+    subject do
+      described_class.perform_now(user,
+                                  title,
+                                  resource_types,
+                                  uploaded_files,
+                                  metadata,
+                                  operation)
+    end
+
+    before do
+      allow(Hyrax::Operation).to receive(:create!).with(user: user,
+                                                        operation_type: "Create Work",
+                                                        parent: operation).and_return(child_operation)
+    end
+
+    it "spawns CreateWorkJobs for each work" do
+      expect(CreateWorkJob).to receive(:perform_later).with(user,
+                                                            "GenericWork",
+                                                            {
+                                                              keyword: [],
+                                                              title: ['File One'],
+                                                              resource_type: ["Article"],
+                                                              uploaded_files: ['1']
+                                                            },
+                                                            child_operation).and_return(true)
+      expect(CreateWorkJob).to receive(:perform_later).with(user,
+                                                            "GenericWork",
+                                                            {
+                                                              keyword: [],
+                                                              title: ['File Two'],
+                                                              resource_type: ["Image"],
+                                                              uploaded_files: ['2']
+                                                            },
+                                                            child_operation).and_return(true)
+      subject
+    end
+
+    context "when multiple resource types are passed for each work." do
+      let(:resource_types) { { upload1.id.to_s => ['Article', 'Text'], upload2.id.to_s => ['Image', 'Text'] } }
+
+      it "spawns CreateWorkJobs for each work" do
+        expect(CreateWorkJob).to receive(:perform_later).with(user,
+                                                              "GenericWork",
+                                                              {
+                                                                keyword: [],
+                                                                title: ['File One'],
+                                                                resource_type: ["Article", 'Text'],
+                                                                uploaded_files: ['1']
+                                                              },
+                                                              child_operation).and_return(true)
+        expect(CreateWorkJob).to receive(:perform_later).with(user,
+                                                              "GenericWork",
+                                                              {
+                                                                keyword: [],
+                                                                title: ['File Two'],
+                                                                resource_type: ["Image", 'Text'],
+                                                                uploaded_files: ['2']
+                                                              },
+                                                              child_operation).and_return(true)
+        subject
+      end
+    end
+  end
+end

data/spec/jobs/characterize_job_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe CharacterizeJob do
+  let(:file_set_id) { 'abc12345' }
+  let(:filename)    { Rails.root.join('tmp', 'uploads', 'ab', 'c1', '23', '45', 'abc12345', 'picture.png').to_s }
+  let(:file_set) do
+    FileSet.new(id: file_set_id).tap do |fs|
+      allow(fs).to receive(:original_file).and_return(file)
+      allow(fs).to receive(:update_index)
+    end
+  end
+  # let(:io)          { JobIoWrapper.new(file_set_id: file_set.id, user: create(:user), path: filename) }
+  let(:file) do
+    Hydra::PCDM::File.new.tap do |f|
+      f.content = 'foo'
+      f.original_name = 'picture.png'
+      f.save!
+      allow(f).to receive(:save!)
+    end
+  end
+
+  before do
+    allow(FileSet).to receive(:find).with(file_set_id).and_return(file_set)
+    allow(Hydra::Works::CharacterizationService).to receive(:run).with(file, filename)
+    allow(CreateDerivativesJob).to receive(:perform_later).with(file_set, file.id, filename)
+  end
+
+  context 'with valid filepath param' do
+    let(:filename) { File.join(fixture_path, 'world.png') }
+
+    it 'skips Hyrax::WorkingDirectory' do
+      expect(Hyrax::WorkingDirectory).not_to receive(:find_or_retrieve)
+      expect(Hydra::Works::CharacterizationService).to receive(:run).with(file, filename)
+      described_class.perform_now(file_set, file.id, filename)
+    end
+  end
+
+  context 'when the characterization proxy content is present' do
+    it 'runs Hydra::Works::CharacterizationService and creates a CreateDerivativesJob' do
+      expect(Hydra::Works::CharacterizationService).to receive(:run).with(file, filename)
+      expect(file).to receive(:save!)
+      expect(file_set).to receive(:update_index)
+      expect(CreateDerivativesJob).to receive(:perform_later).with(file_set, file.id, filename)
+      described_class.perform_now(file_set, file.id)
+    end
+  end
+
+  context 'when the characterization proxy content is absent' do
+    before { allow(file_set).to receive(:characterization_proxy?).and_return(false) }
+    it 'raises an error' do
+      expect { described_class.perform_now(file_set, file.id) }.to raise_error(StandardError, /original_file was not found/)
+    end
+  end
+
+  context "when the file set's work is in a collection" do
+    let(:work)       { build(:generic_work) }
+    let(:collection) { build(:collection) }
+
+    before do
+      allow(file_set).to receive(:parent).and_return(work)
+      allow(work).to receive(:in_collections).and_return([collection])
+    end
+    it "reindexes the collection" do
+      expect(collection).to receive(:update_index)
+      described_class.perform_now(file_set, file.id)
+    end
+  end
+end

data/spec/jobs/content_delete_event_job_spec.rb

@@ -0,0 +1,36 @@
+RSpec.describe ContentDeleteEventJob do
+  let(:user) { create(:user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:event) do
+    {
+      action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> has deleted object '#{curation_concern.id}'",
+      timestamp: '1'
+    }
+  end
+
+  before do
+    allow(Time).to receive(:now).and_return(mock_time)
+  end
+
+  context 'with a FileSet' do
+    let(:curation_concern) { create(:file_set, title: ['Hamlet'], user: user) }
+
+    it "logs the event to the depositor's profile" do
+      expect do
+        described_class.perform_now(curation_concern.id, user)
+      end.to change { user.profile_events.length }.by(1)
+      expect(user.profile_events.first).to eq(event)
+    end
+  end
+
+  context 'with a Work' do
+    let(:curation_concern) { create(:generic_work, title: ['BethsMac'], user: user) }
+
+    it "logs the event to the depositor's profile" do
+      expect do
+        described_class.perform_now(curation_concern.id, user)
+      end.to change { user.profile_events.length }.by(1)
+      expect(user.profile_events.first).to eq(event)
+    end
+  end
+end

data/spec/jobs/content_deposit_event_job_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe ContentDepositEventJob do
+  let(:user) { create(:user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:curation_concern) { create(:work, title: ['MacBeth'], user: user) }
+  let(:event) do
+    {
+      action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> has deposited <a href=\"/concern/generic_works/#{curation_concern.id}\">MacBeth</a>",
+      timestamp: '1'
+    }
+  end
+
+  before do
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the depositor's profile and the Work" do
+    expect do
+      described_class.perform_now(curation_concern, user)
+    end.to change { user.profile_events.length }.by(1)
+                                                .and change { curation_concern.events.length }.by(1)
+
+    expect(user.profile_events.first).to eq(event)
+    expect(curation_concern.events.first).to eq(event)
+  end
+end

data/spec/jobs/content_depositor_change_event_job_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe ContentDepositorChangeEventJob do
+  let(:user) { create(:user) }
+  let(:another_user) { create(:user) }
+  let(:generic_work) { create(:generic_work, title: ['BethsMac'], user: user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:event) do
+    { action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> " \
+                          "has transferred <a href=\"/concern/generic_works/#{generic_work.id}\">BethsMac</a> " \
+                          "to user <a href=\"/users/#{another_user.to_param}\">#{another_user.user_key}</a>",
+      timestamp: '1' }
+  end
+
+  before do
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the proxy depositor's profile, the depositor's dashboard, and the FileSet" do
+    expect do
+      described_class.perform_now(generic_work, another_user)
+    end.to change { user.profile_events.length }.by(1)
+                                                .and change { another_user.events.length }.by(1)
+                                                                                          .and change { generic_work.events.length }.by(1)
+
+    expect(user.profile_events.first).to eq(event)
+    expect(another_user.events.first).to eq(event)
+    expect(generic_work.events.first).to eq(event)
+  end
+end

data/spec/jobs/content_new_version_event_job_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe ContentNewVersionEventJob do
+  let(:user) { create(:user) }
+  let(:file_set) { create(:file_set, title: ['Hamlet'], user: user) }
+  let(:generic_work) { create(:generic_work, title: ['BethsMac'], user: user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:event) { { action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> has added a new version of <a href=\"/concern/file_sets/#{file_set.id}\">Hamlet</a>", timestamp: '1' } }
+
+  before do
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the depositor's profile and the FileSet" do
+    expect do
+      described_class.perform_now(file_set, user)
+    end.to change { user.profile_events.length }.by(1)
+                                                .and change { file_set.events.length }.by(1)
+
+    expect(user.profile_events.first).to eq(event)
+    expect(file_set.events.first).to eq(event)
+  end
+end

data/spec/jobs/content_restored_version_event_job_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe ContentRestoredVersionEventJob do
+  let(:user) { create(:user) }
+  let(:file_set) { create(:file_set, title: ['Hamlet'], user: user) }
+  let(:generic_work) { create(:generic_work, title: ['BethsMac'], user: user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:event) do
+    { action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> " \
+                          "has restored a version 'content.0' of " \
+                          "<a href=\"/concern/file_sets/#{file_set.id}\">Hamlet</a>",
+      timestamp: '1' }
+  end
+
+  before do
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the depositor's profile and the FileSet" do
+    described_class.perform_now(file_set, user, 'content.0')
+    expect do
+      described_class.perform_now(file_set, user, 'content.0')
+    end.to change { user.profile_events.length }.by(1)
+                                                .and change { file_set.events.length }.by(1)
+
+    expect(user.profile_events.first).to eq(event)
+    expect(file_set.events.first).to eq(event)
+  end
+end

data/spec/jobs/content_update_event_job_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe ContentUpdateEventJob do
+  let(:user) { create(:user) }
+  let(:mock_time) { Time.zone.at(1) }
+  let(:curation_concern) { create(:file_set, title: ['Hamlet'], user: user) }
+  let(:event) do
+    {
+      action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> has updated <a href=\"/concern/file_sets/#{curation_concern.id}\">Hamlet</a>",
+      timestamp: '1'
+    }
+  end
+
+  before do
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  it "logs the event to the depositor's profile and the FileSet" do
+    expect do
+      described_class.perform_now(curation_concern, user)
+    end.to change { user.profile_events.length }.by(1)
+                                                .and change { curation_concern.events.length }.by(1)
+
+    expect(user.profile_events.first).to eq(event)
+    expect(curation_concern.events.first).to eq(event)
+  end
+end

data/spec/jobs/create_derivatives_job_spec.rb

@@ -0,0 +1,93 @@
+RSpec.describe CreateDerivativesJob do
+  around do |example|
+    ffmpeg_enabled = Hyrax.config.enable_ffmpeg
+    Hyrax.config.enable_ffmpeg = true
+    example.run
+    Hyrax.config.enable_ffmpeg = ffmpeg_enabled
+  end
+
+  context "with an audio file" do
+    let(:id)       { '123' }
+    let(:file_set) { FileSet.new }
+
+    let(:file) do
+      Hydra::PCDM::File.new.tap do |f|
+        f.content = 'foo'
+        f.original_name = 'picture.png'
+        f.save!
+      end
+    end
+
+    before do
+      allow(FileSet).to receive(:find).with(id).and_return(file_set)
+      allow(file_set).to receive(:id).and_return(id)
+      allow(file_set).to receive(:mime_type).and_return('audio/x-wav')
+    end
+
+    context "with a file name" do
+      it 'calls create_derivatives and save on a file set' do
+        expect(Hydra::Derivatives::AudioDerivatives).to receive(:create)
+        expect(file_set).to receive(:reload)
+        expect(file_set).to receive(:update_index)
+        described_class.perform_now(file_set, file.id)
+      end
+    end
+
+    context 'with a parent object' do
+      before do
+        allow(file_set).to receive(:parent).and_return(parent)
+        # Stub out the actual derivative creation
+        allow(file_set).to receive(:create_derivatives)
+      end
+
+      context 'when the file_set is the thumbnail of the parent' do
+        let(:parent) { GenericWork.new(thumbnail_id: id) }
+
+        it 'updates the index of the parent object' do
+          expect(file_set).to receive(:reload)
+          expect(parent).to receive(:update_index)
+          described_class.perform_now(file_set, file.id)
+        end
+      end
+
+      context "when the file_set isn't the parent's thumbnail" do
+        let(:parent) { GenericWork.new }
+
+        it "doesn't update the parent's index" do
+          expect(file_set).to receive(:reload)
+          expect(parent).not_to receive(:update_index)
+          described_class.perform_now(file_set, file.id)
+        end
+      end
+    end
+  end
+
+  context "with a pdf file" do
+    let(:file_set) { create(:file_set) }
+
+    let(:file) do
+      Hydra::PCDM::File.new do |f|
+        f.content = File.open(File.join(fixture_path, "hyrax/hyrax_test4.pdf"))
+        f.original_name = 'test.pdf'
+        f.mime_type = 'application/pdf'
+      end
+    end
+
+    before do
+      file_set.original_file = file
+      file_set.save!
+    end
+
+    it "runs a full text extract" do
+      expect(Hydra::Derivatives::PdfDerivatives).to receive(:create)
+        .with(/test\.pdf/, outputs: [{ label: :thumbnail,
+                                       format: 'jpg',
+                                       size: '338x493',
+                                       url: String,
+                                       layer: 0 }])
+      expect(Hydra::Derivatives::FullTextExtract).to receive(:create)
+        .with(/test\.pdf/, outputs: [{ url: RDF::URI, container: "extracted_text" }])
+      described_class.perform_now(file_set, file.id)
+    end
+  end
+end

data/spec/jobs/create_work_job_spec.rb

@@ -0,0 +1,60 @@
+RSpec.describe CreateWorkJob do
+  let(:user) { create(:user) }
+  let(:log) do
+    Hyrax::Operation.create!(user: user,
+                             operation_type: "Create Work")
+  end
+
+  describe "#perform", perform_enqueued: [described_class] do
+    let(:file1) { File.open(fixture_path + '/world.png') }
+    let(:upload1) { Hyrax::UploadedFile.create(user: user, file: file1) }
+    let(:metadata) do
+      { keyword: [],
+        "permissions_attributes" => [{ "type" => "group", "name" => "public", "access" => "read" }],
+        "visibility" => 'open',
+        uploaded_files: [upload1.id],
+        title: ['File One'],
+        resource_type: ['Article'] }
+    end
+    let(:errors) { double(full_messages: ["It's broke!"]) }
+    let(:work) { double(errors: errors) }
+    let(:actor) { double(curation_concern: work) }
+
+    subject do
+      described_class.perform_later(user,
+                                    'GenericWork',
+                                    metadata,
+                                    log)
+    end
+
+    before do
+      allow(Hyrax::CurationConcern).to receive(:actor).and_return(actor)
+      allow(GenericWork).to receive(:new).and_return(work)
+    end
+
+    context "when the update is successful" do
+      it "logs the success" do
+        expect(actor).to receive(:create).with(Hyrax::Actors::Environment) do |env|
+          expect(env.attributes).to eq("keyword" => [],
+                                       "title" => ['File One'],
+                                       "resource_type" => ["Article"],
+                                       "permissions_attributes" =>
+                                                 [{ "type" => "group", "name" => "public", "access" => "read" }],
+                                       "visibility" => "open",
+                                       "uploaded_files" => [upload1.id])
+        end.and_return(true)
+        subject
+        expect(log.reload.status).to eq 'success'
+      end
+    end
+
+    context "when the actor does not create the work" do
+      it "logs the failure" do
+        expect(actor).to receive(:create).and_return(false)
+        subject
+        expect(log.reload.status).to eq 'failure'
+        expect(log.message).to eq "It's broke!"
+      end
+    end
+  end
+end

data/spec/jobs/file_set_attached_event_job_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe FileSetAttachedEventJob do
+  let(:user) { create(:user) }
+  let(:mock_time) { Time.zone.at(1) }
+
+  before do
+    allow_any_instance_of(User).to receive(:can?).and_return(true)
+    allow(Time).to receive(:now).at_least(:once).and_return(mock_time)
+  end
+
+  context 'with a FileSet' do
+    let(:file_set) { curation_concern.file_sets.first }
+    let(:curation_concern) { create(:work_with_one_file, title: ['MacBeth'], user: user) }
+    let(:event) do
+      {
+        action: "User <a href=\"/users/#{user.to_param}\">#{user.user_key}</a> " \
+                "has attached <a href=\"/concern/file_sets/#{file_set.id}\">A Contained FileSet</a> " \
+                "to <a href=\"/concern/generic_works/#{curation_concern.id}\">MacBeth</a>",
+        timestamp: '1'
+      }
+    end
+
+    it "logs the event to the right places" do
+      expect do
+        described_class.perform_now(file_set, user)
+      end.to change { user.profile_events.length }.by(1)
+                                                  .and change { file_set.events.length }.by(1)
+                                                                                        .and change { curation_concern.events.length }.by(1)
+
+      expect(user.profile_events.first).to eq(event)
+      expect(curation_concern.events.first).to eq(event)
+      expect(file_set.events.first).to eq(event)
+    end
+  end
+end

data/spec/jobs/fixity_check_job_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe FixityCheckJob do
+  let(:user) { create(:user) }
+
+  let(:file_set) do
+    create(:file_set, user: user).tap do |file|
+      Hydra::Works::AddFileToFileSet.call(file, File.open(fixture_path + '/world.png'), :original_file, versioning: true)
+    end
+  end
+  let(:file_id) { file_set.original_file.id }
+
+  describe "called with perform_now" do
+    let(:log_record) { described_class.perform_now(uri, file_set_id: file_set.id, file_id: file_id) }
+
+    describe 'fixity check the content' do
+      let(:uri) { file_set.original_file.uri }
+
+      it 'passes' do
+        expect(log_record).to be_passed
+      end
+      it "returns a ChecksumAuditLog" do
+        expect(log_record).to be_kind_of ChecksumAuditLog
+        expect(log_record.checked_uri).to eq uri
+        expect(log_record.file_id).to eq file_id
+        expect(log_record.file_set_id).to eq file_set.id
+      end
+    end
+
+    describe 'fixity check a version of the content' do
+      let(:uri) { Hyrax::VersioningService.latest_version_of(file_set.original_file).uri }
+
+      it 'passes' do
+        expect(log_record).to be_passed
+      end
+      it "returns a ChecksumAuditLog" do
+        expect(log_record).to be_kind_of ChecksumAuditLog
+      end
+    end
+
+    describe 'fixity check an invalid version of the content' do
+      let(:uri) { Hyrax::VersioningService.latest_version_of(file_set.original_file).uri + 'bogus' }
+
+      it 'fails' do
+        expect(log_record).to be_failed
+      end
+      it "returns a ChecksumAuditLog" do
+        expect(log_record).to be_kind_of ChecksumAuditLog
+      end
+    end
+  end
+end

data/spec/jobs/hyrax/grant_edit_job_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Hyrax::GrantEditJob do
+  let(:depositor) { create(:user) }
+  let(:file_set) { build(:file_set) }
+
+  it 'grants a user edit access to a FileSet' do
+    expect(FileSet).to receive(:find).with(file_set.id).and_return(file_set)
+    expect(file_set).to receive(:edit_users=).with(array_including(depositor.user_key))
+    expect(file_set).to receive(:save!)
+    described_class.perform_now(file_set.id, depositor.user_key)
+  end
+end

data/spec/jobs/hyrax/grant_edit_to_members_job_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Hyrax::GrantEditToMembersJob do
+  let(:depositor) { create(:user) }
+  let(:work) { build(:work) }
+  let(:file_set_ids) { ['xyz123abc', 'abc789zyx'] }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:file_set_ids).with(work).and_return(file_set_ids)
+  end
+
+  it 'loops over FileSet IDs, spawning a job for each' do
+    file_set_ids.each do |file_set_id|
+      expect(Hyrax::GrantEditJob).to receive(:perform_now).with(file_set_id, depositor.user_key).once
+    end
+    described_class.perform_now(work, depositor.user_key)
+  end
+end

data/spec/jobs/hyrax/grant_read_job_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Hyrax::GrantReadJob do
+  let(:depositor) { create(:user) }
+  let(:file_set) { build(:file_set) }
+
+  it 'grants a user read access to a FileSet' do
+    expect(FileSet).to receive(:find).with(file_set.id).and_return(file_set)
+    expect(file_set).to receive(:read_users=).with(array_including(depositor.user_key))
+    expect(file_set).to receive(:save!)
+    described_class.perform_now(file_set.id, depositor.user_key)
+  end
+end

data/spec/jobs/hyrax/grant_read_to_members_job_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Hyrax::GrantReadToMembersJob do
+  let(:depositor) { create(:user) }
+  let(:work) { build(:work) }
+  let(:file_set_ids) { ['xyz123abc', 'abc789zyx'] }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:file_set_ids).with(work).and_return(file_set_ids)
+  end
+
+  it 'loops over FileSet IDs, spawning a job for each' do
+    file_set_ids.each do |file_set_id|
+      expect(Hyrax::GrantReadJob).to receive(:perform_now).with(file_set_id, depositor.user_key).once
+    end
+    described_class.perform_now(work, depositor.user_key)
+  end
+end

data/spec/jobs/hyrax/revoke_edit_from_members_job_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Hyrax::RevokeEditFromMembersJob do
+  let(:depositor) { create(:user) }
+  let(:work) { build(:work) }
+  let(:file_set_ids) { ['xyz123abc', 'abc789zyx'] }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:file_set_ids).with(work).and_return(file_set_ids)
+  end
+
+  it 'loops over FileSet IDs, spawning a job for each' do
+    file_set_ids.each do |file_set_id|
+      expect(Hyrax::RevokeEditJob).to receive(:perform_now).with(file_set_id, depositor.user_key).once
+    end
+    described_class.perform_now(work, depositor.user_key)
+  end
+end

data/spec/jobs/hyrax/revoke_edit_job_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Hyrax::RevokeEditJob do
+  let(:depositor) { create(:user) }
+  let(:file_set) { build(:file_set, user: depositor) }
+
+  it 'revokes edit access from a FileSet' do
+    expect(FileSet).to receive(:find).with(file_set.id).and_return(file_set)
+    expect(file_set).to receive(:edit_users=).with([])
+    expect(file_set).to receive(:save!)
+    described_class.perform_now(file_set.id, depositor.user_key)
+  end
+end