worthwhile 0.0.1.alpha → 0.0.1

data/lib/worthwhile/spec_support.rb

@@ -0,0 +1,10 @@
+# Given that curate provides custom matchers, factories, etc.
+# When someone makes use of curate in their Rails application
+# Then we should expose those spec support files to that applications
+spec_directory = File.expand_path('../../../spec', __FILE__)
+
+# Dir["#{spec_directory}/factories/**/*.rb"].each { |f| require f }
+Dir["#{spec_directory}/support/curation_concern/*.rb"].each { |f| require f }
+Dir["#{spec_directory}/support/shared/*.rb"].each { |f| require f }
+
+

data/lib/worthwhile/version.rb

@@ -1,3 +1,3 @@
 module Worthwhile
-  VERSION = "0.0.1.alpha"
+  VERSION = "0.0.1"
 end

data/spec/abilities/generic_file_abilities_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require "cancan/matchers"
+
+describe "User" do
+  describe "Abilities" do
+    subject { ability }
+    let(:ability) { Ability.new(current_user) }
+    let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PRIVATE }
+    let(:creating_user) { FactoryGirl.create(:user) }
+    let(:user) { FactoryGirl.create(:user) }
+    let(:current_user) { user }
+    let(:generic_work) {  FactoryGirl.create(:generic_work, visibility: visibility, user:creating_user) }
+    let(:generic_file) {  FactoryGirl.create(:file_with_work, visibility: visibility, user:creating_user) }
+
+    describe 'without embargo' do
+      describe 'creator of object' do
+        let(:creating_user) { user }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, Worthwhile::GenericFile.new)
+          should be_able_to(:read, generic_file)
+          should be_able_to(:update, generic_file)
+          should_not be_able_to(:delete, generic_file)
+        }
+      end
+
+      describe 'as a repository manager' do
+        let(:manager_user) { FactoryGirl.create(:admin) }
+        let(:creating_user) { user }
+        let(:current_user) { manager_user }
+        it {
+          should be_able_to(:create, Worthwhile::GenericFile.new)
+          should be_able_to(:read, generic_file)
+          should be_able_to(:update, generic_file)
+          should be_able_to(:destroy, generic_file)
+        }
+      end
+
+      describe 'another authenticated user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, Worthwhile::GenericFile.new)
+          should_not be_able_to(:read, generic_file)
+          should_not be_able_to(:update, generic_file)
+          should_not be_able_to(:delete, generic_file)
+        }
+      end
+
+      describe 'a nil user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { nil }
+        it {
+          should_not be_able_to(:create, Worthwhile::GenericFile.new)
+          should_not be_able_to(:read, generic_file)
+          should_not be_able_to(:update, generic_file)
+          should_not be_able_to(:delete, generic_file)
+        }
+      end
+    end
+  end
+end

data/spec/abilities/generic_work_abilities_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require "cancan/matchers"
+
+describe "User" do
+  describe "Abilities" do
+    subject { Ability.new(current_user) }
+
+    let(:generic_work) { FactoryGirl.create(:private_generic_work, user: creating_user ) }
+    let(:user) { FactoryGirl.create(:user) }
+
+    describe 'without embargo' do
+      describe 'creator of object' do
+        let(:creating_user) { user }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should be_able_to(:read, generic_work)
+          should be_able_to(:update, generic_work)
+          should be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'as a repository manager' do
+        let(:manager_user) { FactoryGirl.create(:admin) }
+        let(:creating_user) { user }
+        let(:current_user) { manager_user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should be_able_to(:read, generic_work)
+          should be_able_to(:update, generic_work)
+          should be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'another authenticated user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { user }
+        it {
+          should be_able_to(:create, GenericWork.new)
+          should_not be_able_to(:read, generic_work)
+          should_not be_able_to(:update, generic_work)
+          should_not be_able_to(:destroy, generic_work)
+        }
+      end
+
+      describe 'a nil user' do
+        let(:creating_user) { FactoryGirl.create(:user) }
+        let(:current_user) { nil }
+        it {
+          should_not be_able_to(:create, GenericWork.new)
+          should_not be_able_to(:read, generic_work)
+          should_not be_able_to(:update, generic_work)
+          should_not be_able_to(:destroy, generic_work)
+        }
+      end
+    end
+  end
+end

data/spec/actors/curation_concern/generic_work_actor_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe CurationConcern::GenericWorkActor do
+  include ActionDispatch::TestProcess
+
+  let(:user) { FactoryGirl.create(:user) }
+  let(:file) { worthwhile_fixture_file_upload('files/image.png', 'image/png') }
+
+  subject {
+    Worthwhile::CurationConcern.actor(curation_concern, user, attributes)
+  }
+
+  describe '#create' do
+    let(:curation_concern) { GenericWork.new(pid: Worthwhile::CurationConcern.mint_a_pid )}
+
+    context 'failure' do
+      let(:attributes) {{}}
+
+      it 'returns false' do
+        expect_any_instance_of(CurationConcern::GenericWorkActor).to receive(:save).and_return(false)
+        allow(subject).to receive(:attach_files).and_return(true)
+        allow(subject).to receive(:create_linked_resource).and_return(true)
+        expect(subject.create).to be false
+      end
+    end
+
+    context 'valid attributes' 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/"] } }
+
+        context "with a valid embargo date" do
+          let(:date) { Date.today + 2 }
+          it "should interpret 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
+        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
+            expect(subject.create).to be false
+            expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date'
+          end
+        end
+      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/"] } }
+
+        context "with a valid lease date" do
+          let(:date) { Date.today + 2 }
+          it "should interpret 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
+            expect(curation_concern.visibility_during_lease).to eq 'open'
+            expect(curation_concern.visibility_after_lease).to eq 'restricted'
+            expect(curation_concern.visibility).to eq 'open'
+          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
+            expect(subject.create).to be false
+            expect(subject.curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
+          end
+        end
+      end
+
+      context 'with a file' do
+        let(:attributes) {
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap {|a|
+            a[:files] = file
+          }
+        }
+
+        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(Sufia.queue).to receive(:push).with(s2).once
+            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.depositor).to eq user.user_key
+            expect(curation_concern.representative).to_not be_nil
+
+            expect(curation_concern.generic_files.count).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
+            expect(generic_file.content.content).to eq file.read
+            expect(generic_file.filename).to eq 'image.png'
+
+            expect(curation_concern).to be_authenticated_only_access
+            expect(generic_file).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|
+            a[:files] = [file, file]
+          }
+        }
+
+        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(Sufia.queue).to receive(:push).with(s2).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.depositor).to eq user.user_key
+
+            expect(curation_concern.generic_files.count).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 linked resources' do
+
+        let(:attributes) {
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility, linked_resource_urls: ['http://www.youtube.com/watch?v=oHg5SJYRHA0', "http://google.com"])
+        }
+
+        it 'should stamp each link with the access rights' do
+          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.depositor).to eq user.user_key
+
+          expect(curation_concern.generic_files.count).to eq 0
+          expect(curation_concern.linked_resources.count).to eq 2
+          # Sanity test to make sure the file we uploaded is stored and has same permission as parent.
+          link = curation_concern.linked_resources.first
+          expect(link.url).to eq 'http://www.youtube.com/watch?v=oHg5SJYRHA0'
+          expect(curation_concern).to be_authenticated_only_access
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:curation_concern) { FactoryGirl.create(:generic_work, user: user)}
+
+    context 'failure' do
+      let(:attributes) {{}}
+
+      it 'returns false' do
+        expect_any_instance_of(CurationConcern::GenericWorkActor).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
+        expect(subject).to receive(:interpret_lease_visibility).and_return(true)
+        expect(subject).to receive(:interpret_embargo_visibility).and_return(true)
+        subject.update
+      end
+    end
+    context 'adding to collections' do
+      let!(:collection1) { FactoryGirl.create(:collection, user: user) }
+      let!(:collection2) { FactoryGirl.create(:collection, user: user) }
+      let(:attributes) {
+        FactoryGirl.attributes_for(:generic_work,
+                                   visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+                                   collection_ids: [collection2.pid])
+      }
+      before do
+        curation_concern.apply_depositor_metadata(user.user_key)
+        curation_concern.save!
+        collection1.add_member(curation_concern)
+      end
+
+      it "should add to collections" do
+        reload = GenericWork.find(curation_concern.pid)
+        expect(reload.collections).to eq [collection1]
+
+        expect(subject.update).to be true
+
+        reload = GenericWork.find(curation_concern.pid)
+        expect(reload.identifier).to be_blank
+        expect(reload).to be_persisted
+        expect(reload).to be_open_access
+        expect(reload.collections.count).to eq 1
+        expect(reload.collections).to eq [collection2]
+        expect(subject).to be_visibility_changed
+      end
+    end
+  end
+end

data/spec/actors/curation_concern/linked_resource_actor_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe CurationConcern::LinkedResourceActor do
+  let(:user) { FactoryGirl.create(:user) }
+  let(:parent) { FactoryGirl.create(:generic_work, user: user) }
+  let(:link) { Worthwhile::LinkedResource.new.tap {|lr| lr.batch = parent } }
+  let(:you_tube_link) { 'http://www.youtube.com/watch?v=oHg5SJYRHA0' }
+
+  subject {
+    CurationConcern::LinkedResourceActor.new(link, user, url: you_tube_link)
+  }
+
+  describe '#create' do
+    describe 'success' do
+      it 'adds a linked resource to the parent work' do
+        expect(parent.linked_resources).to be_empty
+        subject.create
+        expect(parent.reload.linked_resources).to eq [link]
+        link.reload
+        expect(link.batch).to eq parent
+        expect(link.url).to eq you_tube_link
+      end
+    end
+
+    describe 'failure' do
+      it 'returns false' do
+        allow(link).to receive(:valid?).and_return(false)
+        expect {
+          expect(subject.create).to be false
+        }.to_not change { Worthwhile::LinkedResource.count }
+        expect(parent.reload.linked_resources).to eq []
+      end
+    end
+  end
+
+end

data/spec/actors/worthwile/manages_embargoes_actor_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+describe Worthwhile::ManagesEmbargoesActor do
+
+  let(:model) {
+    Class.new(CurationConcern::BaseActor) {
+      include Worthwhile::ManagesEmbargoesActor
+    }
+  }
+
+  let(:user) { User.new }
+  let(:curation_concern) { GenericWork.new(pid: Worthwhile::CurationConcern.mint_a_pid )}
+  let(:attributes) {{}}
+  subject {
+    model.new(curation_concern, user, attributes)
+  }
+  let(:date) { Date.today+2 }
+
+  context "#interpret_visibility" do
+    it "should interpret 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
+      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 '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
+        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 } }
+
+      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)
+        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
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+        it "should set 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 '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
+        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 } }
+
+      it "should apply 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
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE } }
+        it "should set 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
+      end
+    end
+  end
+end