hyrax 2.6.0 → 2.9.0

data/spec/jobs/attach_files_to_work_job_spec.rb

@@ -1,80 +0,0 @@
-RSpec.describe AttachFilesToWorkJob, perform_enqueued: [AttachFilesToWorkJob] do
-  let(:file1) { File.open(fixture_path + '/world.png') }
-  let(:file2) { File.open(fixture_path + '/image.jp2') }
-  let(:uploaded_file1) { build(:uploaded_file, file: file1) }
-  let(:uploaded_file2) { build(:uploaded_file, file: file2) }
-  let(:generic_work) { create(:public_generic_work) }
-  let(:user) { create(:user) }
-
-  shared_examples 'a file attacher', perform_enqueued: [AttachFilesToWorkJob, IngestJob] do
-    it 'attaches files, copies visibility and permissions and updates the uploaded files' do
-      expect(CharacterizeJob).to receive(:perform_later).twice
-      described_class.perform_now(generic_work, [uploaded_file1, uploaded_file2])
-      generic_work.reload
-      expect(generic_work.file_sets.count).to eq 2
-      expect(generic_work.file_sets.map(&:visibility)).to all(eq 'open')
-      expect(uploaded_file1.reload.file_set_uri).not_to be_nil
-      expect(ImportUrlJob).not_to have_been_enqueued
-    end
-  end
-
-  context "with uploaded files on the filesystem" do
-    before do
-      generic_work.permissions.build(name: 'userz@bbb.ddd', type: 'person', access: 'edit')
-      generic_work.save
-    end
-    it_behaves_like 'a file attacher' do
-      it 'records the depositor(s) in edit_users' do
-        expect(generic_work.file_sets.map(&:edit_users)).to all(match_array([generic_work.depositor, 'userz@bbb.ddd']))
-      end
-
-      describe 'with existing files' do
-        let(:file_set)       { create(:file_set) }
-        let(:uploaded_file1) { build(:uploaded_file, file: file1, file_set_uri: 'http://example.com/file_set') }
-
-        it 'skips files that already have a FileSet' do
-          expect { described_class.perform_now(generic_work, [uploaded_file1, uploaded_file2]) }
-            .to change { generic_work.file_sets.count }.to eq 1
-        end
-      end
-    end
-  end
-
-  context "with uploaded files at remote URLs" do
-    let(:url1) { 'https://example.com/my/img.png' }
-    let(:url2) { URI('https://example.com/other/img.png') }
-    let(:fog_file1) { double(CarrierWave::Storage::Abstract, url: url1) }
-    let(:fog_file2) { double(CarrierWave::Storage::Abstract, url: url2) }
-
-    before do
-      allow(uploaded_file1.file).to receive(:file).and_return(fog_file1)
-      allow(uploaded_file2.file).to receive(:file).and_return(fog_file2)
-    end
-
-    it_behaves_like 'a file attacher'
-  end
-
-  context "deposited on behalf of another user" do
-    before do
-      generic_work.on_behalf_of = user.user_key
-      generic_work.save
-    end
-    it_behaves_like 'a file attacher' do
-      it 'records the depositor(s) in edit_users' do
-        expect(generic_work.file_sets.map(&:edit_users)).to all(match_array([user.user_key]))
-      end
-    end
-  end
-
-  context "deposited as 'Yourself' selected in on behalf of list" do
-    before do
-      generic_work.on_behalf_of = ''
-      generic_work.save
-    end
-    it_behaves_like 'a file attacher' do
-      it 'records the depositor(s) in edit_users' do
-        expect(generic_work.file_sets.map(&:edit_users)).to all(match_array([generic_work.depositor]))
-      end
-    end
-  end
-end

data/spec/jobs/attach_files_to_work_with_ordered_members_job_spec.rb

@@ -1,13 +0,0 @@
-RSpec.describe AttachFilesToWorkWithOrderedMembersJob, perform_enqueued: [AttachFilesToWorkWithOrderedMembersJob] do
-  let(:file1) { File.open(fixture_path + '/world.png') }
-  let(:file2) { File.open(fixture_path + '/image.jp2') }
-  let(:uploaded_file1) { build(:uploaded_file, file: file1) }
-  let(:uploaded_file2) { build(:uploaded_file, file: file2) }
-  let(:generic_work) { create(:public_generic_work) }
-
-  it "attaches files and passes ordered_members to OrderedMembersActor" 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(generic_work)
-    described_class.perform_now(generic_work, [uploaded_file1, uploaded_file2])
-  end
-end

data/spec/jobs/batch_create_job_spec.rb

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

@@ -1,66 +0,0 @@
-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_lw) }
-
-    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

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

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

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

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

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

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

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