curation_concerns 0.1.0 → 0.2.0

data/spec/actors/curation_concerns/work_actor_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'redlock'
 
 describe CurationConcerns::GenericWorkActor do
   include ActionDispatch::TestProcess
@@ -6,18 +7,26 @@ describe CurationConcerns::GenericWorkActor do
   let(:user) { FactoryGirl.create(:user) }
   let(:file) { curation_concerns_fixture_file_upload('files/image.png', 'image/png') }
 
-  subject {
-    CurationConcerns::CurationConcern.actor(curation_concern, user, attributes)
+  let(:redlock_client_stub) { # 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)
+    client
   }
 
+  subject do
+    CurationConcerns::CurationConcern.actor(curation_concern, user, attributes)
+  end
+
   describe '#create' do
     let(:curation_concern) { GenericWork.new }
+    let(:xmas) { DateTime.parse('2014-12-25 11:30') }
 
     context 'failure' do
-      let(:attributes) {{}}
+      let(:attributes) { {} }
 
       it 'returns false' do
-        expect_any_instance_of(CurationConcerns::GenericWorkActor).to receive(:save).and_return(false)
+        expect_any_instance_of(described_class).to receive(:save).and_return(false)
         allow(subject).to receive(:attach_files).and_return(true)
         expect(subject.create).to be false
       end
@@ -27,26 +36,52 @@ describe CurationConcerns::GenericWorkActor do
       let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
 
       context 'with embargo' do
-        let(:attributes) { { 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",
-                           rights: ["http://creativecommons.org/licenses/by/3.0/us/"] } }
+        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',
+            rights: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+        end
 
-        context "with a valid embargo date" do
+        context 'with a valid embargo date' do
           let(:date) { Date.today + 2 }
-          it "should interpret and apply embargo and lease visibility settings" do
+          it 'interprets and apply embargo and lease visibility settings' do
             subject.create
             expect(curation_concern).to be_persisted
             expect(curation_concern.visibility_during_embargo).to eq 'authenticated'
             expect(curation_concern.visibility_after_embargo).to eq 'open'
             expect(curation_concern.visibility).to eq 'authenticated'
           end
+          context "with attached files" do
+            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',
+                files: [
+                  file
+                ],
+                rights: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+            end
+
+            before { redlock_client_stub }
+
+            it "applies it to attached files" do
+              allow(CharacterizeJob).to receive(:perform_later).and_return(true)
+              subject.create
+              file = curation_concern.file_sets.first
+              expect(file).to be_persisted
+              expect(file.visibility_during_embargo).to eq 'authenticated'
+              expect(file.visibility_after_embargo).to eq 'open'
+              expect(file.visibility).to eq 'authenticated'
+            end
+          end
         end
 
-        context "when embargo_release_date is in the past" do
-          let(:date) { Date.today-2 }
-          it "should set error on curation_concern and return false" do
+        context 'when embargo_release_date is in the past' do
+          let(:date) { Date.today - 2 }
+          it 'sets error on curation_concern and return false' do
             expect(subject.create).to be false
             expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date'
           end
@@ -54,15 +89,17 @@ describe CurationConcerns::GenericWorkActor do
       end
 
       context 'with lease' do
-        let(:attributes) { { title: ["New embargo"], visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
-                           visibility_during_embargo: "authenticated", embargo_release_date: '2099-05-12',
-                           visibility_after_embargo: "open", visibility_during_lease: "open",
-                           lease_expiration_date: date.to_s, visibility_after_lease: "restricted",
-                           rights: ["http://creativecommons.org/licenses/by/3.0/us/"] } }
+        let(:attributes) do
+          { title: ['New embargo'], visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+            visibility_during_embargo: 'authenticated', embargo_release_date: '2099-05-12',
+            visibility_after_embargo: 'open', visibility_during_lease: 'open',
+            lease_expiration_date: date.to_s, visibility_after_lease: 'restricted',
+            rights: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+        end
 
-        context "with a valid lease date" do
+        context 'with a valid lease date' do
           let(:date) { Date.today + 2 }
-          it "should interpret and apply embargo and lease visibility settings" do
+          it 'interprets and apply embargo and lease visibility settings' do
             subject.create
             expect(curation_concern).to be_persisted
             expect(curation_concern.embargo_release_date).to be_nil
@@ -72,9 +109,9 @@ describe CurationConcerns::GenericWorkActor do
           end
         end
 
-        context "when lease_expiration_date is in the past" do
-          let(:date) { Date.today-2 }
-          it "should set error on curation_concern and return false" do
+        context 'when lease_expiration_date is in the past' do
+          let(:date) { Date.today - 2 }
+          it 'sets error on curation_concern and return false' do
             expect(subject.create).to be false
             expect(subject.curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
           end
@@ -82,55 +119,61 @@ describe CurationConcerns::GenericWorkActor do
       end
 
       context 'with a file' do
-        let(:attributes) {
-          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap {|a|
+        let(:attributes) do
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap do |a|
             a[:files] = file
-          }
-        }
+          end
+        end
 
         context 'authenticated visibility' do
-          it 'should stamp each file with the access rights' do
-            s2 = double('characterize job')
-            allow(CharacterizeJob).to receive(:new).and_return(s2)
-            expect(CurationConcerns.queue).to receive(:push).with(s2).once
+          before do
+            allow(CurationConcerns::TimeService).to receive(:time_in_utc) { xmas }
+            redlock_client_stub
+          end
+
+          it 'stamps each file with the access rights' do
+            expect(CharacterizeJob).to receive(:perform_later)
             expect(subject.create).to be true
             expect(curation_concern).to be_persisted
-            expect(curation_concern.date_uploaded).to eq Date.today
-            expect(curation_concern.date_modified).to eq Date.today
+            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).to_not be_nil
-            expect(curation_concern.generic_files.size).to eq 1
+            expect(curation_concern.file_sets.size).to eq 1
             # Sanity test to make sure the file we uploaded is stored and has same permission as parent.
-            generic_file = curation_concern.generic_files.first
+            file_set = curation_concern.file_sets.first
             file.rewind
-            expect(generic_file.original_file.content).to eq file.read
+            expect(file_set.reload.original_file.content).to eq file.read
 
             expect(curation_concern).to be_authenticated_only_access
-            expect(generic_file).to be_authenticated_only_access
+            expect(file_set).to be_authenticated_only_access
           end
         end
       end
 
       context 'with multiple files file' do
-        let(:attributes) {
-          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap {|a|
+        let(:attributes) do
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap do|a|
             a[:files] = [file, file]
-          }
-        }
+          end
+        end
 
         context 'authenticated visibility' do
-          it 'should stamp each file with the access rights' do
-            s2 = double('characterize job')
-            allow(CharacterizeJob).to receive(:new).and_return(s2)
-            expect(CurationConcerns.queue).to receive(:push).with(s2).twice
+          before do
+            allow(CurationConcerns::TimeService).to receive(:time_in_utc) { xmas }
+            redlock_client_stub
+          end
+
+          it 'stamps each file with the access rights' do
+            expect(CharacterizeJob).to receive(:perform_later).twice
 
             expect(subject.create).to be true
             expect(curation_concern).to be_persisted
-            expect(curation_concern.date_uploaded).to eq Date.today
-            expect(curation_concern.date_modified).to eq Date.today
+            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.generic_files.size).to eq 2
+            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
@@ -138,12 +181,12 @@ describe CurationConcerns::GenericWorkActor do
         end
       end
 
-      context "with a present and a blank title" do
-        let(:attributes) {
+      context 'with a present and a blank title' do
+        let(:attributes) do
           FactoryGirl.attributes_for(:generic_work, title: ['this is present', ''])
-        }
+        end
 
-        it 'should stamp each link with the access rights' do
+        it 'stamps each link with the access rights' do
           expect(subject.create).to be true
           expect(curation_concern).to be_persisted
           expect(curation_concern.title).to eq ['this is present']
@@ -153,20 +196,20 @@ describe CurationConcerns::GenericWorkActor do
   end
 
   describe '#update' do
-    let(:curation_concern) { FactoryGirl.create(:generic_work, user: user)}
+    let(:curation_concern) { FactoryGirl.create(:generic_work, user: user) }
 
     context 'failure' do
-      let(:attributes) {{}}
+      let(:attributes) { {} }
 
       it 'returns false' do
-        expect_any_instance_of(CurationConcerns::GenericWorkActor).to receive(:save).and_return(false)
+        expect_any_instance_of(described_class).to receive(:save).and_return(false)
         expect(subject.update).to be false
       end
     end
 
     context 'valid attributes' do
-      let(:attributes) {{}}
-      it "should interpret and apply embargo and lease visibility settings" do
+      let(:attributes) { {} }
+      it 'interprets and apply embargo and lease visibility settings' do
         expect(subject).to receive(:interpret_lease_visibility).and_return(true)
         expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
         subject.update
@@ -176,18 +219,18 @@ describe CurationConcerns::GenericWorkActor do
     context 'adding to collections' do
       let!(:collection1) { FactoryGirl.create(:collection, user: user) }
       let!(:collection2) { FactoryGirl.create(:collection, user: user) }
-      let(:attributes) {
+      let(:attributes) do
         FactoryGirl.attributes_for(:generic_work, collection_ids: [collection2.id])
-      }
+      end
       before do
         curation_concern.apply_depositor_metadata(user.user_key)
         curation_concern.save!
         collection1.add_member(curation_concern)
       end
 
-      it "remove from the old collection and adds to the new collection" do
+      it 'remove from the old collection and adds to the new collection' do
         curation_concern.reload
-        expect(curation_concern.parent_collections).to eq [collection1]
+        expect(curation_concern.in_collections).to eq [collection1]
         # before running actor.update, the work is in collection1
 
         expect(subject.update).to be true
@@ -196,7 +239,22 @@ describe CurationConcerns::GenericWorkActor do
         expect(curation_concern.identifier).to be_blank
         expect(curation_concern).to be_persisted
         # after running actor.update, the work is in collection2 and no longer in collection1
-        expect(curation_concern.parent_collections).to eq [collection2]
+        expect(curation_concern.in_collections).to eq [collection2]
+      end
+    end
+
+    context 'with multiple file sets' do
+      let(:file_set1) { create(:file_set) }
+      let(:file_set2) { create(:file_set) }
+      let(:curation_concern) { FactoryGirl.create(:generic_work, user: user, members: [file_set1, file_set2]) }
+      let(:attributes) do
+        FactoryGirl.attributes_for(:generic_work, members: [file_set2, file_set1])
+      end
+      xit 'updates the order of file sets' do
+        expect(curation_concern.ordered_members).to eq [file_set1, file_set2]
+        expect(subject.update).to be true
+        curation_concern.reload
+        expect(curation_concern.ordered_members).to eq [file_set2, file_set1]
       end
     end
   end

data/spec/controllers/catalog_controller_spec.rb

@@ -5,37 +5,37 @@ describe CatalogController do
     ActiveFedora::Base.delete_all
   end
 
-  describe "when logged in" do
+  describe 'when logged in' do
     let(:user)    { FactoryGirl.create(:user) }
     let!(:work1)  { FactoryGirl.create(:work_with_one_file, user: user) }
     let!(:work2)  { FactoryGirl.create(:public_generic_work) }
     let!(:collection) { FactoryGirl.create(:collection, user: user) }
-    let!(:file)   { work1.generic_files.first }
+    let!(:file) { work1.file_sets.first }
     before do
       sign_in user
     end
 
-    context "when there is private content" do
+    context 'when there is private content' do
       let!(:private_work) { FactoryGirl.create(:private_generic_work) }
 
-      it "excludes it" do
+      it 'excludes it' do
         get 'index'
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
       end
     end
 
-    context "Searching all content" do
-      it "should exclude linked resources" do
+    context 'Searching all content' do
+      it 'excludes linked resources' do
         get 'index'
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to match_array [work1.id, work2.id, collection.id]
       end
     end
 
-    context "Searching all works" do
-      it "should return all the works" do
-        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+    context 'Searching all works' do
+      it 'returns all the works' do
+        get 'index', 'f' => { 'generic_type_sim' => 'Work' }
         expect(response).to be_successful
         expect(assigns(:document_list).count).to eq 2
         [work1.id, work2.id].each do |work_id|
@@ -44,44 +44,43 @@ describe CatalogController do
       end
     end
 
-    context "Searching all collections" do
-      it "should return all the works" do
-        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+    context 'Searching all collections' do
+      it 'returns all the works' do
+        get 'index', 'f' => { 'generic_type_sim' => 'Collection' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to eq [collection.id]
       end
     end
 
-    context "searching just my works" do
-      it "should return just my works" do
-        get 'index', works: 'mine', 'f' => {'generic_type_sim' => 'Work'}
+    context 'searching just my works' do
+      it 'returns just my works' do
+        get 'index', works: 'mine', 'f' => { 'generic_type_sim' => 'Work' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to eq [work1.id]
       end
     end
 
-    context "searching for one kind of work" do
-      it "returns just the specified type" do
-        get 'index', 'f' => {'human_readable_type_sim' => 'Generic Work'}
+    context 'searching for one kind of work' do
+      it 'returns just the specified type' do
+        get 'index', 'f' => { 'human_readable_type_sim' => 'Generic Work' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to include(work1.id, work2.id)
       end
     end
 
-    context "when json is requested for autosuggest of related works" do
+    context 'when json is requested for autosuggest of related works' do
       let!(:work) { FactoryGirl.create(:generic_work, user: user, title: ["All my #{srand}"]) }
-      it "should return json" do
+      it 'returns json' do
         xhr :get, :index, format: :json, q: work.title
         json = JSON.parse(response.body)
         # Grab the doc corresponding to work and inspect the json
-        work_json = json["docs"].first
-        expect(work_json).to eq("pid"=>work.id, "title"=> "#{work.title.first} (#{work.human_readable_type})")
+        work_json = json['docs'].first
+        expect(work_json).to eq('pid' => work.id, 'title' => "#{work.title.first} (#{work.human_readable_type})")
       end
     end
-
   end
 
-  describe "when logged in as a repository manager" do
+  describe 'when logged in as a repository manager' do
     let(:creating_user) { FactoryGirl.create(:user) }
     let(:manager_user) { FactoryGirl.create(:user) }
     let!(:work1) { FactoryGirl.create(:private_generic_work, user: creating_user) }
@@ -93,23 +92,22 @@ describe CatalogController do
       sign_in manager_user
     end
 
-    context "searching all works" do
-      it "should return other users' private works" do
-        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+    context 'searching all works' do
+      it "returns other users' private works" do
+        get 'index', 'f' => { 'generic_type_sim' => 'Work' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to include(work1.id)
       end
-      it "should return other users' embargoed works" do
-        get 'index', 'f' => {'generic_type_sim' => 'Work'}
+      it "returns other users' embargoed works" do
+        get 'index', 'f' => { 'generic_type_sim' => 'Work' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to include(work2.id)
       end
-      it "should return other users' private collections" do
-        get 'index', 'f' => {'generic_type_sim' => 'Collection'}
+      it "returns other users' private collections" do
+        get 'index', 'f' => { 'generic_type_sim' => 'Collection' }
         expect(response).to be_successful
         expect(assigns(:document_list).map(&:id)).to include(collection.id)
       end
     end
-
   end
 end

data/spec/controllers/curation_concerns/classify_concerns_controller_spec.rb

@@ -31,13 +31,12 @@ describe CurationConcerns::ClassifyConcernsController do
         expect(subject).to receive(:new_polymorphic_path).with([:curation_concerns, GenericWork]).and_return(main_app.new_curation_concerns_generic_work_path)
       end
 
-      let(:new_curation_concern_generic_work_path) { "/stub/path" }
+      let(:new_curation_concern_generic_work_path) { '/stub/path' }
 
       it 'requires authentication' do
         post :create, classify_concern: { curation_concern_type: 'GenericWork' }
         expect(response).to redirect_to(main_app.new_curation_concerns_generic_work_path)
       end
-   end
-
+    end
   end
 end