hyrax 2.9.6 → 3.0.0.pre.beta1

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

@@ -0,0 +1,347 @@
+require 'redlock'
+
+RSpec.describe Hyrax::Actors::FileSetActor do
+  include ActionDispatch::TestProcess
+
+  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) }
+
+  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(:work) { create(:generic_work) }
+    let(:date_today) { DateTime.current }
+
+    subject { file_set.reload }
+
+    before do
+      allow(DateTime).to receive(:current).and_return(date_today)
+      allow(actor).to receive(:acquire_lock_for).and_yield
+      actor.create_metadata
+      actor.create_content(file)
+      actor.attach_to_work(work)
+    end
+
+    context 'when a work is provided' do
+      it 'adds the FileSet to the parent work' do
+        expect(subject.parents).to eq [work]
+        expect(work.reload.file_sets).to include(subject)
+
+        # Confirming that date_uploaded and date_modified were set
+        expect(subject.date_uploaded).to eq date_today.utc
+        expect(subject.date_modified).to eq date_today.utc
+        expect(subject.depositor).to eq user.email
+
+        # Confirm that embargo/lease are not set.
+        expect(subject).not_to be_under_embargo
+        expect(subject).not_to be_active_lease
+        expect(subject.visibility).to eq 'restricted'
+      end
+    end
+  end
+
+  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
+
+    it 'calls ingest_file' do
+      actor.create_content(file)
+    end
+
+    context 'when an alternative relationship is specified' do
+      let(:relation) { :remastered }
+
+      it 'calls ingest_file' do
+        actor.create_content(file, :remastered)
+      end
+    end
+
+    context 'using ::File' do
+      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))
+        expect(file_set.title).to eq([File.basename(local_file)])
+      end
+
+      it 'gets the mime_type from original_file' do
+        expect(file_set.mime_type).to eq('image/png')
+      end
+    end
+
+    context 'when file_set.title is empty and file_set.label is not' do
+      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' }
+
+      before do
+        allow(file_set).to receive(:label).and_return(short_name)
+        actor.create_content(file)
+      end
+
+      subject { file_set.title }
+
+      it { is_expected.to match_array [short_name] }
+    end
+
+    context 'when a label is already specified' 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, user) }
+
+      before do
+        actor.create_content(file)
+      end
+
+      it "retains the object's original label" do
+        expect(file_set.label).to eql(label)
+      end
+    end
+  end
+
+  describe '#create_content when from_url is true' do
+    before do
+      expect(JobIoWrapper).to receive(:create_with_varied_file_handling!).with(any_args).once.and_call_original
+    end
+
+    it 'calls ingest_file and kicks off jobs' do
+      actor.create_content(file, from_url: true)
+      expect(VisibilityCopyJob).to have_been_enqueued
+      expect(InheritPermissionsJob).to have_been_enqueued
+    end
+
+    context 'when an alternative relationship is specified' do
+      before do
+        # Relationship must be declared before being used. Inject it here.
+        FileSet.class_eval do
+          directly_contains_one :remastered, through: :files, type: ::RDF::URI("http://otherpcdm.example.org/use#Remastered"), class_name: 'Hydra::PCDM::File'
+        end
+      end
+
+      it 'calls ingest_file' do
+        actor.create_content(file, :remastered, from_url: true)
+      end
+    end
+
+    context 'using ::File' do
+      let(:file) { local_file }
+
+      before { actor.create_content(local_file, from_url: true) }
+
+      it 'sets the label and title' do
+        expect(file_set.label).to eq(File.basename(local_file))
+        expect(file_set.title).to eq([File.basename(local_file)])
+      end
+
+      it 'gets the mime_type from original_file' do
+        expect(file_set.mime_type).to eq('image/png')
+      end
+    end
+
+    context 'when file_set.title is empty and file_set.label is not' do
+      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' }
+
+      before do
+        allow(file_set).to receive(:label).and_return(short_name)
+        actor.create_content(file, from_url: true)
+      end
+
+      subject { file_set.title }
+
+      it { is_expected.to match_array [short_name] }
+    end
+
+    context 'when a label is already specified' 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, user) }
+
+      before do
+        actor.create_content(file, from_url: true)
+      end
+
+      it "retains the object's original label" do
+        expect(file_set.label).to eql(label)
+      end
+    end
+  end
+
+  describe "#update_metadata" do
+    it "is successful" do
+      expect(actor.update_metadata("title" => ["updated title"])).to be true
+      expect(file_set.reload.title).to eq ["updated title"]
+    end
+  end
+
+  describe "#update_content" do
+    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', perform_enqueued: [IngestJob] do
+      # 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
+  end
+
+  describe "#destroy" do
+    it "destroys the object" do
+      actor.destroy
+      expect { file_set.reload }.to raise_error ActiveFedora::ObjectNotFoundError
+    end
+
+    context "representative, renderings and thumbnail of a work" do
+      let!(:work) do
+        work = create(:generic_work)
+        # this is not part of a block on the create, since the work must be saved
+        # before the representative can be assigned
+        work.ordered_members << file_set
+        work.representative = file_set
+        work.thumbnail = file_set
+        work.renderings = [file_set]
+        work.save
+        work
+      end
+
+      it "removes representative, renderings, thumbnail, and the proxy association" do
+        gw = GenericWork.find(work.id)
+        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.reload
+        expect(gw.representative_id).to be_nil
+        expect(gw.thumbnail_id).to be_nil
+        expect(gw.rendering_ids).to eq([])
+      end
+    end
+  end
+
+  describe "#attach_to_work" do
+    let(:work) { build(:public_generic_work) }
+
+    before do
+      allow(actor).to receive(:acquire_lock_for).and_yield
+    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 '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.id, work.thumbnail.id] }
+      end
+    end
+
+    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 'with multiple versions' do
+      let(:work_v1) { create(:generic_work) } # this version of the work has no members
+
+      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
+
+      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
+    subject { actor.file_actor_class }
+
+    it { is_expected.to eq(Hyrax::Actors::FileActor) }
+
+    context "overridden" do
+      let(:custom_fs_actor_class) do
+        class ::CustomFileActor < Hyrax::Actors::FileActor
+        end
+        Class.new(described_class) do
+          def file_actor_class
+            CustomFileActor
+          end
+        end
+      end
+      let(:actor) { custom_fs_actor_class.new(file_set, user) }
+
+      after { Object.send(:remove_const, :CustomFileActor) }
+      it { is_expected.to eq(CustomFileActor) }
+    end
+  end
+
+  describe '#revert_content', perform_enqueued: [IngestJob] do
+    let(:file_set) { create(:file_set, user: user) }
+    let(:file1)    { "small_file.txt" }
+    let(:version1) { "version1" }
+    let(:restored_content) { file_set.reload.original_file }
+
+    before do
+      actor.create_content(fixture_file_upload(file1))
+      actor.create_content(fixture_file_upload('hyrax_generic_stub.txt'))
+      actor.file_set.reload
+    end
+
+    it "restores the first versions's content and metadata" do
+      actor.revert_content(version1)
+      expect(restored_content.original_name).to eq file1
+    end
+  end
+end

data/spec/actors/hyrax/actors/file_set_ordered_members_actor_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Hyrax::Actors::FileSetOrderedMembersActor do
+  include ActionDispatch::TestProcess
+
+  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) }
+
+  describe 'creating metadata, content and attaching to a work' do
+    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)
+      allow(actor).to receive(:acquire_lock_for).and_yield
+      actor.create_metadata
+      actor.create_content(file)
+      actor.attach_to_work(work)
+    end
+
+    context 'when a work is provided' do
+      it 'does not add the FileSet to the parent work' do
+        expect(subject.parents).to eq []
+        expect(subject.visibility).to eq 'restricted'
+        expect(work.reload.file_sets).not_to include(subject)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,316 @@
+require 'redlock'
+
+RSpec.describe Hyrax::Actors::GenericWorkActor do
+  include ActionDispatch::TestProcess
+  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
+  let(:user) { create(:user) }
+  let(:ability) { ::Ability.new(user) }
+  let(:admin_set) { create(:admin_set, id: 'admin_set_1', with_permission_template: { with_active_workflow: true }) }
+  # stub out redis connection
+  let(:redlock_client_stub) do
+    client = double('redlock client')
+    allow(client).to receive(:lock).and_yield(true)
+    allow(Redlock::Client).to receive(:new).and_return(client)
+    client
+  end
+
+  subject { Hyrax::CurationConcern.actor }
+
+  describe '#create' do
+    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(middleware).to receive(:attach_files).and_return(true)
+      end
+
+      # 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(middleware.create(env)).to be false
+      end
+    end
+
+    context 'success' 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
+        expect(Hyrax.config.callback).to receive(:run)
+          .with(:after_create_concern, curation_concern, user)
+        middleware.create(env)
+      end
+    end
+
+    context 'valid attributes', perform_enqueued: [AttachFilesToWorkJob, IngestJob] do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+
+      before { redlock_client_stub }
+
+      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,
+              uploaded_files: uploaded_file_ids,
+              license: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+          end
+
+          it "applies embargo to attached files" do
+            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
+
+      context 'with in_work_ids' do
+        let(:parent) { create(:generic_work, user: user) }
+        let(:attributes) do
+          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(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(middleware.create(env)).to be false
+          expect(curation_concern.reload.in_works).to eq []
+        end
+      end
+
+      context 'with a file' do
+        let(:attributes) do
+          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)
+            allow(Hyrax.config.callback).to receive(:run).with(:after_create_concern, GenericWork, user)
+          end
+
+          it 'stamps each file with the access rights and runs callbacks' 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(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
+            expect(curation_concern.depositor).to eq user.user_key
+            expect(curation_concern.representative).not_to be_nil
+            expect(curation_concern.file_sets.size).to eq 1
+            expect(curation_concern).to be_authenticated_only_access
+            # Sanity test to make sure the file_set has same permission as parent.
+            file_set = curation_concern.file_sets.first
+            expect(file_set).to be_authenticated_only_access
+          end
+        end
+      end
+
+      context 'with multiple files' do
+        let(:file_actor) { double }
+        let(:uploaded_file2) { Hyrax::UploadedFile.create(file: file, user: user) }
+        let(:attributes) do
+          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
+
+        context 'authenticated visibility' do
+          before do
+            allow(Hyrax::TimeService).to receive(:time_in_utc) { xmas }
+            allow(Hyrax::Actors::FileActor).to receive(:new).and_return(file_actor)
+          end
+
+          it 'stamps each file with the access rights' do
+            expect(file_actor).to receive(:ingest_file).and_return(true).twice
+
+            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
+            expect(curation_concern.depositor).to eq user.user_key
+
+            expect(curation_concern.file_sets.size).to eq 2
+            # Sanity test to make sure the file we uploaded is stored and has same permission as parent.
+
+            expect(curation_concern).to be_authenticated_only_access
+          end
+        end
+      end
+
+      context 'with a present and a blank title' do
+        let(:attributes) do
+          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(middleware.create(env)).to be true
+          expect(curation_concern).to be_persisted
+          expect(curation_concern.title).to eq ['this is present']
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:curation_concern) { create(:generic_work, user: user, admin_set_id: admin_set.id) }
+
+    context 'failure' do
+      let(:attributes) { {} }
+
+      it 'returns false' do
+        expect(curation_concern).to receive(:save).and_return(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(env)
+      end
+    end
+
+    context 'with in_works_ids' do
+      let(:parent) { create(:generic_work, user: user) }
+      let(:old_parent) { create(:generic_work, user: user) }
+      let(:attributes) do
+        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(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) { create(:generic_work) }
+      let(:attributes) do
+        attributes_for(:generic_work).merge(
+          in_works_ids: []
+        )
+      end
+
+      before do
+        curation_concern.apply_depositor_metadata(user.user_key)
+        curation_concern.save!
+        old_parent.ordered_members << curation_concern
+        old_parent.save!
+      end
+      it "removes the old parent" do
+        allow(curation_concern).to receive(:depositor).and_return(old_parent.depositor)
+        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) { create(:generic_work) }
+      let(:attributes) do
+        attributes_for(:generic_work).merge(
+          in_works_ids: nil
+        )
+      end
+
+      before do
+        curation_concern.apply_depositor_metadata(user.user_key)
+        curation_concern.save!
+        parent.ordered_members << curation_concern
+        parent.save!
+      end
+      it "does nothing" do
+        expect(subject.update(env)).to be true
+        expect(curation_concern.in_works).to eq [parent]
+      end
+    end
+
+    context 'with multiple file sets' do
+      let(:file_set1) { create(:file_set) }
+      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
+        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(env)).to be true
+
+        curation_concern.reload
+        expect(curation_concern.ordered_members.to_a).to eq [file_set2, file_set1]
+      end
+      ## Is this something we want to support?
+      context "when told to stop ordering a file set" do
+        let(:attributes) do
+          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(env)).to be true
+
+          curation_concern.reload
+          expect(curation_concern.ordered_members.to_a).to eq [file_set2]
+        end
+      end
+    end
+  end
+end