hyrax 2.6.0 → 2.7.0

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

@@ -1,35 +0,0 @@
-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

@@ -1,316 +0,0 @@
-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

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

@@ -1,35 +0,0 @@
-RSpec.describe Hyrax::Actors::InitializeWorkflowActor do
-  let(:user) { create(:user) }
-  let(:ability) { ::Ability.new(user) }
-  let(:curation_concern) { build(:generic_work) }
-  let(:attributes) { { title: ['test'] } }
-
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-      middleware.use Hyrax::Actors::GenericWorkActor
-    end
-    stack.build(terminator)
-  end
-
-  describe 'the next actor' do
-    it 'passes the attributes on' do
-      expect(terminator).to receive(:create).with(Hyrax::Actors::Environment)
-      subject.create(env)
-    end
-  end
-
-  describe 'create' do
-    let(:curation_concern) { build(:generic_work, admin_set: admin_set) }
-    let!(:admin_set) { create(:admin_set, with_permission_template: { with_workflows: true }) }
-
-    it 'creates an entity' do
-      expect do
-        expect(subject.create(env)).to be true
-      end.to change { Sipity::Entity.count }.by(1)
-    end
-  end
-end

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

@@ -1,445 +0,0 @@
-RSpec.describe Hyrax::Actors::InterpretVisibilityActor do
-  let(:user) { create(:user) }
-  let(:ability) { ::Ability.new(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, source_id: admin_set.id) }
-  let(:terminator) { Hyrax::Actors::Terminator.new }
-  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 }
-  let(:env) { Hyrax::Actors::Environment.new(curation_concern, ability, attributes) }
-
-  subject(:middleware) do
-    stack = ActionDispatch::MiddlewareStack.new.tap do |middleware|
-      middleware.use described_class
-      middleware.use Hyrax::Actors::GenericWorkActor
-    end
-    stack.build(terminator)
-  end
-
-  describe 'the next actor' do
-    let(:terminator) { instance_double(Hyrax::Actors::Terminator) }
-
-    before do
-      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(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
-          expect(k.attributes).to eq("visibility" => 'open')
-          false
-        end
-        subject.create(env)
-      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(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
-          expect(k.attributes.keys).not_to include(:visibility)
-          false
-        end
-        subject.create(env)
-      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(env)).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(terminator).to receive(:create).with(Hyrax::Actors::Environment) do |k|
-          expect(k.attributes.keys).not_to include(:visibility)
-          false
-        end
-        subject.create(env)
-      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(env)).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',
-          license: ['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(env)
-          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(env)).to be false
-          expect(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(env)).to be false
-          expect(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(env)).to be false
-          expect(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, source_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(env)).to be false
-          expect(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,
-                 source_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(env)).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,
-                 source_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(env)).to be false
-          expect(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,
-                 source_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(env)).to be true
-        end
-      end
-
-      context "embargo with valid embargo date and invalid post-embargo visibility" do
-        let(:permission_template) do
-          create(:permission_template,
-                 source_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(env)).to be false
-          expect(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,
-                 source_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(env)).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,
-                 source_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(env)).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,
-                 source_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(env)).to be false
-          expect(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,
-                 source_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(env)).to be false
-          expect(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, source_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(env)).to be true
-        end
-      end
-
-      context "visibility public (no embargo) when visibility required to be authenticated" do
-        let(:permission_template) do
-          create(:permission_template,
-                 source_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(env)).to be false
-          expect(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,
-                 source_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(env)).to be true
-        end
-      end
-
-      context "lease specified with any release/visibility requirements" do
-        let(:permission_template) do
-          create(:permission_template,
-                 source_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(env)).to be false
-          expect(env.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, source_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(env)).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',
-          license: ['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(env)
-          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(env)).to be false
-          expect(curation_concern.errors[:lease_expiration_date].first).to eq 'Must be a future date'
-        end
-      end
-    end
-  end
-end