curation_concerns 0.1.0 → 0.2.0

data/spec/actors/curation_concerns/embargo_actor_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe CurationConcerns::EmbargoActor do
+  let(:actor) { described_class.new(work) }
+
+  let(:work) do
+    GenericWork.new do |work|
+      work.apply_depositor_metadata 'foo'
+      work.title = ["test"]
+      work.visibility = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+      work.visibility_during_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+      work.visibility_after_embargo = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.embargo_release_date = release_date.to_s
+      work.save(validate: false)
+    end
+  end
+
+  describe "#destroy" do
+    context "with an active embargo" do
+      let(:release_date) { Date.today + 2 }
+
+      it "removes the embargo" do
+        actor.destroy
+        expect(work.reload.embargo_release_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED
+      end
+    end
+
+    context 'with an expired embargo' do
+      let(:release_date) { Date.today - 2 }
+      it "removes the embargo" do
+        actor.destroy
+        expect(work.reload.embargo_release_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      end
+    end
+  end
+end

data/spec/actors/curation_concerns/file_set_actor_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+require 'redlock'
+
+describe CurationConcerns::FileSetActor do
+  include ActionDispatch::TestProcess
+
+  let(:user) { create(:user) }
+  let(:file_set) { create(:file_set) }
+  let(:actor) { described_class.new(file_set, user) }
+  let(:uploaded_file) { fixture_file_upload('/world.png', 'image/png') }
+
+  describe 'creating metadata and content' do
+    let(:upload_set_id) { nil }
+    let(:work) { nil }
+    subject { file_set.reload }
+    let(:date_today) { DateTime.now }
+
+    before do
+      allow(DateTime).to receive(:now).and_return(date_today)
+    end
+
+    before do
+      expect(CharacterizeJob).to receive(:perform_later)
+      expect(IngestFileJob).to receive(:perform_later).with(file_set.id, /world\.png$/, 'image/png', user.user_key)
+      allow(actor).to receive(:acquire_lock_for).and_yield
+      actor.create_metadata(upload_set_id, work)
+      actor.create_content(uploaded_file)
+    end
+
+    context 'when an upload_set_id and work are not provided' do
+      let(:upload_set_id) { nil }
+      it "leaves the associations blank" do
+        expect(subject.upload_set).to be_nil
+        expect(subject.generic_works).to be_empty
+      end
+    end
+
+    context 'when a upload_set_id is provided' do
+      let(:upload_set_id) { ActiveFedora::Noid::Service.new.mint }
+      it "leaves the association blank" do
+        expect(subject.upload_set).to be_instance_of UploadSet
+      end
+    end
+
+    context 'when a work is provided' do
+      let(:work) { FactoryGirl.create(:generic_work) }
+
+      it 'adds the generic file to the parent work' do
+        expect(subject.generic_works).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).to_not be_under_embargo
+        expect(subject).to_not be_active_lease
+        expect(subject.visibility).to eq 'restricted'
+      end
+    end
+  end
+
+  describe "#create_metadata" do
+    let(:work) { create(:public_generic_work) }
+
+    it 'copies visibility from the parent' do
+      allow(actor).to receive(:acquire_lock_for).and_yield
+      actor.create_metadata(nil, work)
+      saved_file = file_set.reload
+      expect(saved_file.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+    end
+  end
+
+  describe '#create_content' do
+    it 'calls ingest file job' do
+      expect(CharacterizeJob).to receive(:perform_later)
+      expect(IngestFileJob).to receive(:perform_later).with(file_set.id, /world\.png$/, 'image/png', user.user_key)
+      actor.create_content(uploaded_file)
+    end
+
+    context 'when file_set.title is empty and file_set.label is not' do
+      let(:file)       { 'world.png' }
+      let(:long_name)  { 'an absurdly long title that goes on way to long and messes up the display of the page which should not need to be this big in order to show this impossibly long, long, long, oh so long string' }
+      let(:short_name) { 'Nice Short Name' }
+      let(:actor)      { described_class.new(file_set, user) }
+
+      before do
+        allow(CharacterizeJob).to receive(:perform_later)
+        allow(file_set).to receive(:label).and_return(short_name)
+        actor.create_content(fixture_file_upload(file))
+      end
+
+      subject { file_set.title }
+
+      it { is_expected.to eql [short_name] }
+    end
+
+    context 'when a label is already specified' do
+      let(:file)     { 'world.png' }
+      let(:label)    { 'test_file.png' }
+      let(:file_set_with_label) do
+        FileSet.new do |f|
+          f.apply_depositor_metadata(user.user_key)
+          f.label = label
+        end
+      end
+      let(:actor) { described_class.new(file_set_with_label, user) }
+
+      before do
+        allow(IngestFileJob).to receive(:perform_later)
+        allow(CharacterizeJob).to receive(:perform_later)
+        actor.create_content(fixture_file_upload(file))
+      end
+
+      it "retains the object's original label" do
+        expect(file_set_with_label.label).to eql(label)
+      end
+    end
+  end
+
+  describe "#destroy" do
+    it "destroys the object" do
+      actor.destroy
+      expect { file_set.reload }.to raise_error ActiveFedora::ObjectNotFoundError
+    end
+    context "representative 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.members << file_set
+        work.representative = file_set
+        work.save
+        work
+      end
+
+      it "removes representative" do
+        expect(work.reload.representative_id).to eq(file_set.id)
+        actor.destroy
+        expect(work.reload.representative_id).to be_nil
+      end
+    end
+  end
+
+  describe "#attach_file_to_work" do
+    before do
+      # stub out redis connection
+      client = double('redlock client')
+      allow(client).to receive(:lock).and_yield(true)
+      allow(Redlock::Client).to receive(:new).and_return(client)
+    end
+
+    let(:file_set2) { create(:file_set) }
+    let(:file_set3) { create(:file_set) }
+
+    # The first version of the work has a single member.
+    let!(:work_v1) do
+      work = create(:generic_work)
+      work.ordered_members << file_set
+      work.save
+      work
+    end
+
+    # Create another version of the same work with a second member.
+    let!(:work_v2) do
+      work = ActiveFedora::Base.find(work_v1.id)
+      work.ordered_members << file_set2
+      work.save
+      work
+    end
+
+    it "writes to the most up to date version" do
+      # using send(), because attach_file_to_work is private
+      actor.send(:attach_file_to_work, work_v1, file_set3, {})
+      expect(work_v1.members.size).to eq 3
+    end
+  end
+end

data/spec/actors/curation_concerns/lease_actor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe CurationConcerns::LeaseActor do
+  let(:actor) { described_class.new(work) }
+
+  let(:work) do
+    GenericWork.new do |work|
+      work.apply_depositor_metadata 'foo'
+      work.title = ["test"]
+      work.visibility_during_lease = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      work.visibility_after_lease = Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      work.lease_expiration_date = release_date.to_s
+      work.save(validate: false)
+    end
+  end
+
+  describe "#destroy" do
+    before do
+      actor.destroy
+    end
+
+    context "with an active lease" do
+      let(:release_date) { Date.today + 2 }
+
+      it "removes the lease" do
+        expect(work.reload.lease_expiration_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC
+      end
+    end
+
+    context 'with an expired lease' do
+      let(:release_date) { Date.today - 2 }
+      it "removes the lease" do
+        expect(work.reload.lease_expiration_date).to be_nil
+        expect(work.visibility).to eq Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE
+      end
+    end
+  end
+end

data/spec/actors/curation_concerns/manages_embargoes_actor_spec.rb

@@ -1,91 +1,97 @@
 require 'spec_helper'
 describe CurationConcerns::ManagesEmbargoesActor do
-
-  let(:model) {
-    Class.new(CurationConcerns::BaseActor) {
+  let(:model) do
+    Class.new(CurationConcerns::BaseActor) do
       include CurationConcerns::ManagesEmbargoesActor
-    }
-  }
+    end
+  end
 
   let(:user) { User.new }
   let(:curation_concern) { GenericWork.new }
-  let(:attributes) {{}}
-  subject {
+  let(:attributes) { {} }
+  subject do
     model.new(curation_concern, user, attributes)
-  }
-  let(:date) { Date.today+2 }
+  end
+  let(:date) { Date.today + 2 }
 
-  context "#interpret_visibility" do
-    it "should interpret lease and embargo visibility" do
+  context '#interpret_visibility' do
+    it 'interprets lease and embargo visibility' do
       expect(subject).to receive(:interpret_lease_visibility).and_return(true)
       expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
       expect(subject.interpret_visibility).to be true
     end
-    it "should collect failures from interpreting lease & embargo visibility" do
+    it 'collects failures from interpreting lease & embargo visibility' do
       expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
       expect(subject).to receive(:interpret_lease_visibility).and_return(false)
       expect(subject.interpret_visibility).to be false
     end
   end
 
-  context "#interpret_embargo_visibility" do
+  context '#interpret_embargo_visibility' do
     context 'when visibility is not set to embargo' do
-      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
-                           visibility_during_embargo: 'restricted', visibility_after_embargo: 'open' } }
-      it "removes the embargo attributes and returns true" do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          visibility_during_embargo: 'restricted', visibility_after_embargo: 'open' }
+      end
+      it 'removes the embargo attributes and returns true' do
         expect(subject.interpret_embargo_visibility).to be true
         expect(subject.attributes.keys).to eq ['visibility']
       end
     end
 
-    context "when visibility is set to embargo" do
-      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
-                           visibility_during_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
-                           visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
-                           embargo_release_date: date.to_s } }
+    context 'when visibility is set to embargo' do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+          visibility_during_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
+          visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          embargo_release_date: date.to_s }
+      end
 
-      it "should apply the embargo remove embargo attributes except for embargo_release_date and return true" do
-        expect(subject.curation_concern).to receive(:apply_embargo).with(date.to_s, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+      it 'applies the embargo remove embargo attributes except for embargo_release_date and return true' do
+        expect(subject.curation_concern).to receive(:apply_embargo).with(date.to_s, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
         expect(subject.interpret_embargo_visibility).to be true
         expect(subject.attributes.keys).to eq ['embargo_release_date']
       end
 
-      context "when embargo_release_date is not set" do
+      context 'when embargo_release_date is not set' do
         let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
-        it "should set error on curation_concern and return false" do
+        it 'sets error on curation_concern and return false' do
           expect(subject.interpret_embargo_visibility).to be false
           expect(subject.curation_concern.errors[:visibility].first).to eq 'When setting visibility to "embargo" you must also specify embargo release date.'
         end
       end
-
     end
   end
 
-  context "#interpret_lease_visibility" do
+  context '#interpret_lease_visibility' do
     context 'when visibility is not set to lease' do
-      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
-                           visibility_during_lease: 'open', visibility_after_lease: 'restricted' } }
-      it "removes the lease attributes and returns true" do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          visibility_during_lease: 'open', visibility_after_lease: 'restricted' }
+      end
+      it 'removes the lease attributes and returns true' do
         expect(subject.interpret_lease_visibility).to be true
         expect(subject.attributes.keys).to eq ['visibility']
       end
     end
 
-    context "when visibility is set to lease" do
-      let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
-                           visibility_during_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
-                           visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
-                           lease_expiration_date: date.to_s } }
+    context 'when visibility is set to lease' do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+          visibility_during_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE,
+          visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          lease_expiration_date: date.to_s }
+      end
 
-      it "should apply the lease, remove lease attributes except for lease_expiration_date and return true" do
+      it 'applies the lease, remove lease attributes except for lease_expiration_date and return true' do
         expect(subject.curation_concern).to receive(:apply_lease).with(date.to_s, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE, Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
         expect(subject.interpret_lease_visibility).to be true
         expect(subject.attributes.keys).to eq ['lease_expiration_date']
       end
 
-      context "when lease_expiration_date is not set" do
+      context 'when lease_expiration_date is not set' do
         let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE } }
-        it "should set error on curation_concern and return false" do
+        it 'sets error on curation_concern and return false' do
           expect(subject.interpret_lease_visibility).to be false
           expect(subject.curation_concern.errors[:visibility].first).to eq 'When setting visibility to "lease" you must also specify lease expiration date.'
         end