test_hyrax 0.0.1.alpha

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

@@ -0,0 +1,313 @@
+require 'spec_helper'
+require 'redlock'
+
+describe Hyrax::Actors::GenericWorkActor do
+  include ActionDispatch::TestProcess
+
+  let(:user) { create(:user) }
+  let(:file_path) { File.join(fixture_path, 'image.png') }
+  let(:file) { Rack::Test::UploadedFile.new(file_path, 'image/png', false) }
+  # 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 do
+    Hyrax::CurationConcern.actor(curation_concern, user)
+  end
+
+  describe '#create' do
+    let(:curation_concern) { GenericWork.new }
+    let(:xmas) { DateTime.parse('2014-12-25 11:30').iso8601 }
+
+    context 'failure' do
+      let(:attributes) { {} }
+      before do
+        allow(subject).to receive(:attach_files).and_return(true)
+      end
+
+      it 'returns false' do
+        expect(curation_concern).to receive(:save).and_return(false)
+        expect(subject.create(attributes)).to be false
+      end
+    end
+
+    context 'success' do
+      before do
+        redlock_client_stub
+        create(:workflow_action)
+      end
+
+      it "invokes the after_create_concern callback" do
+        allow(CharacterizeJob).to receive(:perform_later).and_return(true)
+        expect(Hyrax.config.callback).to receive(:run)
+          .with(:after_create_concern, curation_concern, user)
+
+        subject.create(title: ['Foo Bar'])
+      end
+    end
+
+    context 'valid attributes' do
+      let(:visibility) { Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+      before do
+        redlock_client_stub
+        create(:workflow_action)
+      end
+
+      context 'with embargo' do
+        context "with attached files" do
+          let(:date) { Time.zone.today + 2 }
+          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
+
+          it "applies embargo to attached files" do
+            allow(CharacterizeJob).to receive(:perform_later).and_return(true)
+            subject.create(attributes)
+            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 'with in_work_ids' do
+        let(:parent) { FactoryGirl.create(:generic_work) }
+        let(:attributes) do
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).merge(
+            in_works_ids: [parent.id]
+          )
+        end
+        it "attaches the parent" do
+          expect(subject.create(attributes)).to be true
+          expect(curation_concern.in_works).to eq [parent]
+        end
+      end
+
+      context 'with a file' do
+        let(:attributes) do
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap do |a|
+            a[:files] = file
+          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(subject.create(attributes)).to be true
+            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(:attributes) do
+          FactoryGirl.attributes_for(:generic_work, visibility: visibility).tap do |a|
+            a[:files] = [file, file]
+          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(subject.create(attributes)).to be true
+            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
+          FactoryGirl.attributes_for(:generic_work, title: ['this is present', ''])
+        end
+
+        it 'stamps each link with the access rights' do
+          expect(subject.create(attributes)).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) }
+
+    context 'failure' do
+      let(:attributes) { {} }
+
+      it 'returns false' do
+        expect(curation_concern).to receive(:save).and_return(false)
+        expect(subject.update(attributes)).to be false
+      end
+    end
+
+    context 'success' do
+      it "invokes the after_update_metadata callback" do
+        expect(Hyrax.config.callback).to receive(:run)
+          .with(:after_update_metadata, curation_concern, user)
+        subject.update(title: ['Other Title'])
+      end
+    end
+
+    context 'with in_works_ids' do
+      let(:parent) { FactoryGirl.create(:generic_work) }
+      let(:old_parent) { FactoryGirl.create(:generic_work) }
+      let(:attributes) do
+        FactoryGirl.attributes_for(:generic_work).merge(
+          in_works_ids: [parent.id]
+        )
+      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 "attaches the parent" do
+        expect(subject.update(attributes)).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) { FactoryGirl.create(:generic_work) }
+      let(:attributes) do
+        FactoryGirl.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
+        expect(subject.update(attributes)).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) { FactoryGirl.create(:generic_work) }
+      let(:attributes) do
+        FactoryGirl.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(attributes)).to be true
+        expect(curation_concern.in_works).to eq [parent]
+      end
+    end
+    context 'adding to collections' do
+      let!(:collection1) { create(:collection, user: user) }
+      let!(:collection2) { create(:collection, user: user) }
+      let(:attributes) do
+        FactoryGirl.attributes_for(:generic_work, member_of_collection_ids: [collection2.id])
+      end
+      before do
+        curation_concern.apply_depositor_metadata(user.user_key)
+        curation_concern.member_of_collections = [collection1]
+        curation_concern.save!
+      end
+
+      it 'remove from the old collection and adds to the new collection' do
+        curation_concern.reload
+        expect(curation_concern.member_of_collection_ids).to eq [collection1.id]
+        # before running actor.update, the work is in collection1
+
+        expect(subject.update(attributes)).to be true
+
+        curation_concern.reload
+        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.member_of_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) { create(:generic_work, user: user, ordered_members: [file_set1, file_set2]) }
+      let(:attributes) do
+        FactoryGirl.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(attributes)).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
+          FactoryGirl.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(attributes)).to be true
+
+          curation_concern.reload
+          expect(curation_concern.ordered_members.to_a).to eq [file_set2]
+        end
+      end
+    end
+  end
+end

data/spec/actors/hyrax/actors/initialize_workflow_actor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+describe Hyrax::Actors::InitializeWorkflowActor, :workflow do
+  let(:user) { create(:user) }
+  let(:curation_concern) { GenericWork.new }
+  let(:attributes) { { title: ['test'] } }
+
+  subject do
+    Hyrax::Actors::ActorStack.new(curation_concern,
+                                  user,
+                                  [described_class,
+                                   Hyrax::Actors::GenericWorkActor])
+  end
+
+  describe 'the next actor' do
+    let(:root_actor) { double }
+    before do
+      allow(Hyrax::Actors::RootActor).to receive(:new).and_return(root_actor)
+    end
+
+    it 'passes the attributes on' do
+      expect(root_actor).to receive(:create).with(title: ['test'])
+      subject.create(attributes)
+    end
+  end
+
+  describe 'create' do
+    it 'creates an entity' do
+      expect do
+        expect(subject.create(attributes)).to be true
+      end.to change { Sipity::Entity.count }.by(1)
+    end
+  end
+end

data/spec/actors/hyrax/actors/interpret_visibility_actor_spec.rb

@@ -0,0 +1,426 @@
+require 'spec_helper'
+describe Hyrax::Actors::InterpretVisibilityActor do
+  let(:user) { create(:user) }
+  let(:curation_concern) { GenericWork.new }
+  let(:attributes) { { admin_set_id: admin_set.id } }
+  let(:admin_set) { create(:admin_set) }
+  let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id) }
+
+  subject do
+    Hyrax::Actors::ActorStack.new(curation_concern,
+                                  user,
+                                  [described_class,
+                                   Hyrax::Actors::GenericWorkActor])
+  end
+  let(:one_year_from_today) { Time.zone.today + 1.year }
+  let(:two_years_from_today) { Time.zone.today + 2.years }
+  let(:date) { Time.zone.today + 2 }
+
+  describe 'the next actor' do
+    let(:root_actor) { double }
+    before do
+      allow(Hyrax::Actors::RootActor).to receive(:new).and_return(root_actor)
+      allow(curation_concern).to receive(:save).and_return(true)
+    end
+
+    context 'when visibility is set to open' do
+      let(:attributes) do
+        { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC,
+          visibility_during_embargo: 'restricted',
+          visibility_after_embargo: 'open',
+          embargo_release_date: date.to_s }
+      end
+
+      it 'does not receive the embargo attributes' do
+        expect(root_actor).to receive(:create).with(visibility: 'open')
+        subject.create(attributes)
+      end
+    end
+
+    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 'does not receive the visibility attribute' do
+        expect(root_actor).to receive(:create).with(hash_excluding(:visibility))
+        subject.create(attributes)
+      end
+
+      context 'when embargo_release_date is not set' do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+        it 'does not clear the visibility attributes' do
+          expect(subject.create(attributes)).to be false
+          expect(attributes).to eq(visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO)
+        end
+      end
+    end
+
+    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 'removes lease attributes' do
+        expect(root_actor).to receive(:create).with(hash_excluding(:visibility))
+        subject.create(attributes)
+      end
+
+      context 'when lease_expiration_date is not set' do
+        let(:attributes) { { visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE } }
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(attributes)).to be false
+          expect(attributes).to eq(visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE)
+        end
+      end
+    end
+  end
+
+  describe 'create' do
+    context 'with embargo' 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',
+          rights: ['http://creativecommons.org/licenses/by/3.0/us/'] }
+      end
+
+      context 'with a valid embargo date (and no template requirements)' do
+        let(:date) { Time.zone.today + 2 }
+        it 'interprets and apply embargo and lease visibility settings' do
+          subject.create(attributes)
+          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 "embargo with invalid embargo date" do
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: 'ffff' }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template # Ensuring permission_template is loaded
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date.'
+        end
+      end
+
+      context 'when embargo_release_date is in the past' do
+        let(:date) { Time.zone.today - 2 }
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Must be a future date.'
+        end
+      end
+
+      context "embargo with missing embargo date" do
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO } }
+        it "returns false and logs error on visibility field" do
+          permission_template # Ensuring permission_template is loaded
+          expect(subject.create(attributes)).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
+
+      context "embargo with date = one year from today, and required embargo of 6 months or less" do
+        let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id, release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_6_MONTHS) }
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Release date specified does not match permission template release requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with date = one year from today, and required embargo of 1 year or less" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "embargo with date that doesn't match a required, fixed date" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
+                 release_date: one_year_from_today.to_s)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: two_years_from_today.to_s }
+        end
+
+        it "returns false and logs error on date field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:embargo_release_date].first).to eq 'Release date specified does not match permission template release requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with date matching the required, fixed date" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
+                 release_date: two_years_from_today.to_s)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: two_years_from_today.to_s }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "embargo with valid embargo date and invalid post-embargo visibility" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED }
+        end
+
+        it "returns false and logs error on visibility field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:visibility_after_embargo].first).to eq 'Visibility after embargo does not match permission template visibility requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo with valid embargo date and valid post-embargo visibility" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "embargo with public visibility and public visibility required (no specified release_period in template)" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "embargo with public visibility and authenticated visibility required (no specified release_period in template)" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s,
+            visibility_after_embargo: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns false and logs error on visibility field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:visibility_after_embargo].first).to eq 'Visibility after embargo does not match permission template visibility requirements for selected AdminSet.'
+        end
+      end
+
+      context "embargo when no release delays are allowed" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO,
+            embargo_release_date: one_year_from_today.to_s }
+        end
+
+        it "returns false and logs error on visiblity field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:visibility].first).to eq 'Visibility specified does not match permission template "no release delay" requirement for selected AdminSet.'
+        end
+      end
+
+      context "no embargo/lease when no release delays are allowed" do
+        let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id, release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY) }
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "visibility public (no embargo) when visibility required to be authenticated" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_AUTHENTICATED)
+        end
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns false and logs an error on visibility field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:visibility].first).to eq 'Visibility specified does not match permission template visibility requirement for selected AdminSet.'
+        end
+      end
+
+      context "visibility public (no embargo) and visibility required to be public" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) { { title: ['New embargo'], admin_set_id: admin_set.id, visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC } }
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+
+      context "lease specified with any release/visibility requirements" do
+        let(:permission_template) do
+          create(:permission_template,
+                 admin_set_id: admin_set.id,
+                 release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
+                 visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC)
+        end
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+            lease_expiration_date: one_year_from_today.to_s,
+            visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns false and logs an error on visibility field" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:visibility].first).to eq 'Lease option is not allowed by permission template for selected AdminSet.'
+        end
+      end
+
+      context "lease specified with NO release/visibility requirements" do
+        let(:permission_template) { create(:permission_template, admin_set_id: admin_set.id) }
+        let(:attributes) do
+          { title: ['New embargo'],
+            admin_set_id: admin_set.id,
+            visibility: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE,
+            lease_expiration_date: one_year_from_today.to_s,
+            visibility_after_lease: Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_PUBLIC }
+        end
+
+        it "returns true" do
+          permission_template.reload
+          expect(subject.create(attributes)).to be true
+        end
+      end
+    end
+
+    context 'with lease' do
+      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
+        let(:date) { Time.zone.today + 2 }
+        it 'interprets and apply embargo and lease visibility settings' do
+          subject.create(attributes)
+          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) { Time.zone.today - 2 }
+        it 'sets error on curation_concern and return false' do
+          expect(subject.create(attributes)).to be false
+          expect(subject.curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
+        end
+      end
+    end
+  end
+end