hyrax 3.0.0.pre.beta3 → 3.0.0

data/spec/forms/hyrax/forms/collection_form_spec.rb

@@ -1,199 +0,0 @@
-RSpec.describe Hyrax::Forms::CollectionForm do
-  describe "#terms" do
-    subject { described_class.terms }
-
-    it do
-      is_expected.to eq [:alt_title,
-                         :resource_type,
-                         :title,
-                         :creator,
-                         :contributor,
-                         :description,
-                         :keyword,
-                         :license,
-                         :publisher,
-                         :date_created,
-                         :subject,
-                         :language,
-                         :representative_id,
-                         :thumbnail_id,
-                         :identifier,
-                         :based_near,
-                         :related_url,
-                         :visibility,
-                         :collection_type_gid]
-    end
-  end
-
-  let(:collection) { build(:collection_lw) }
-  let(:ability) { Ability.new(create(:user)) }
-  let(:repository) { double }
-  let(:form) { described_class.new(collection, ability, repository) }
-
-  describe "#primary_terms" do
-    subject { form.primary_terms }
-
-    it { is_expected.to eq([:title, :description]) }
-  end
-
-  describe "#secondary_terms" do
-    subject { form.secondary_terms }
-
-    it do
-      is_expected.to eq [
-        :alt_title,
-        :creator,
-        :contributor,
-        :keyword,
-        :license,
-        :publisher,
-        :date_created,
-        :subject,
-        :language,
-        :identifier,
-        :based_near,
-        :related_url,
-        :resource_type
-      ]
-    end
-  end
-
-  describe '#display_additional_fields?' do
-    subject { form.display_additional_fields? }
-
-    context 'with no secondary terms' do
-      before do
-        allow(form).to receive(:secondary_terms).and_return([])
-      end
-      it { is_expected.to be false }
-    end
-    context 'with secondary terms' do
-      before do
-        allow(form).to receive(:secondary_terms).and_return([:foo, :bar])
-      end
-      it { is_expected.to be true }
-    end
-  end
-
-  context "nested relationships" do
-    let(:child_collection) { build(:collection_lw) }
-    let(:parent_collection) { build(:collection_lw) }
-    let(:service_object) { double(available_member_subcollections: double(documents: [child_collection])) }
-
-    before do
-      allow(collection).to receive(:member_of_collections).and_return([parent_collection])
-      allow(form).to receive(:collection_member_service).and_return(service_object)
-    end
-
-    describe "#list_parent_collections" do
-      subject { form.list_parent_collections }
-
-      it { is_expected.to eq([parent_collection]) }
-    end
-
-    describe "#list_child_collections" do
-      subject { form.list_child_collections }
-
-      it { is_expected.to eq([child_collection]) }
-    end
-  end
-
-  describe "#id" do
-    subject { form.id }
-
-    it { is_expected.to be_nil }
-  end
-
-  describe "#required?" do
-    subject { form.required?(:title) }
-
-    it { is_expected.to be true }
-  end
-
-  describe "#human_readable_type" do
-    subject { form.human_readable_type }
-
-    it { is_expected.to eq 'Collection' }
-  end
-
-  describe "#member_ids" do
-    before do
-      allow(collection).to receive(:member_ids).and_return(['9999'])
-    end
-    subject { form.member_ids }
-
-    it { is_expected.to eq ['9999'] }
-  end
-
-  describe ".build_permitted_params" do
-    subject { described_class.build_permitted_params }
-
-    it do
-      is_expected.to eq [{ alt_title: [] },
-                         { resource_type: [] },
-                         { title: [] },
-                         { creator: [] },
-                         { contributor: [] },
-                         { description: [] },
-                         { keyword: [] },
-                         { license: [] },
-                         { publisher: [] },
-                         { date_created: [] },
-                         { subject: [] },
-                         { language: [] },
-                         :representative_id,
-                         :thumbnail_id,
-                         { identifier: [] },
-                         { based_near: [] },
-                         { related_url: [] },
-                         :visibility,
-                         :collection_type_gid,
-                         { permissions_attributes: [:type, :name, :access, :id, :_destroy] }]
-    end
-  end
-
-  describe '#select_files' do
-    subject { form.select_files }
-
-    let(:collection) { create(:collection) }
-    let(:repository) { Hyrax::CollectionsController.new.repository }
-
-    context 'without any works/files attached' do
-      it { is_expected.to be_empty }
-    end
-
-    context 'with a work/file attached' do
-      let!(:work) { create(:work_with_one_file, :public, member_of_collections: [collection]) }
-      let(:title) { work.file_sets.first.title.first }
-      let(:file_id) { work.file_sets.first.id }
-
-      it 'returns a hash of with file title as key and file id as value' do
-        expect(subject).to eq(title => file_id)
-      end
-    end
-  end
-
-  describe "#permission_template" do
-    subject { form.permission_template }
-
-    context "when the PermissionTemplate doesn't exist" do
-      let(:model) { build(:collection_lw) }
-
-      it "gets created" do
-        expect(subject).to be_instance_of Hyrax::Forms::PermissionTemplateForm
-        expect(subject.model).to be_instance_of Hyrax::PermissionTemplate
-      end
-    end
-
-    context "when the PermissionTemplate exists" do
-      let(:form) { described_class.new(model, ability, repository) }
-      let(:permission_template) { Hyrax::PermissionTemplate.find_by(source_id: model.id) }
-      let(:model) { build(:collection_lw, with_permission_template: true) }
-
-      it "uses the existing template" do
-        expect(subject).to be_instance_of Hyrax::Forms::PermissionTemplateForm
-        expect(subject.model).to eq permission_template
-      end
-    end
-  end
-end

data/spec/forms/hyrax/forms/dashboard/nest_collection_form_spec.rb

@@ -1,159 +0,0 @@
-RSpec.describe Hyrax::Forms::Dashboard::NestCollectionForm, type: :form do
-  let(:parent) { double(nestable?: true) }
-  let(:child) { double(nestable?: true) }
-  let(:context) { double('Context') }
-  let(:nesting_depth_result) { true }
-  let(:query_service) { double('Query Service', valid_combined_nesting_depth?: nesting_depth_result) }
-  let(:persistence_service) { double('Persistence Service', persist_nested_collection: true) }
-  let(:form) { described_class.new(parent: parent, child: child, context: context, query_service: query_service, persistence_service: persistence_service) }
-
-  subject { form }
-
-  it { is_expected.to validate_presence_of(:parent) }
-  it { is_expected.to validate_presence_of(:child) }
-
-  describe '.default_query_service' do
-    subject { described_class.default_query_service }
-
-    it { is_expected.to respond_to(:available_parent_collections) }
-    it { is_expected.to respond_to(:available_child_collections) }
-    it { is_expected.to respond_to(:parent_and_child_can_nest?) }
-    it { is_expected.to respond_to(:valid_combined_nesting_depth?) }
-  end
-
-  describe '#default_query_service' do
-    subject { described_class.default_persistence_service }
-
-    it { is_expected.to respond_to(:persist_nested_collection_for) }
-  end
-
-  context 'parent and child nesting' do
-    let(:nesting_depth_result) { false }
-
-    it 'is invalid if child cannot be nested within the parent' do
-      expect(query_service).to receive(:parent_and_child_can_nest?).with(parent: parent, child: child, scope: context).and_return(false)
-      subject.valid?
-      expect(subject.errors[:parent]).to eq(["cannot have child nested within it"])
-      expect(subject.errors[:child]).to eq(["cannot nest within parent"])
-      expect(subject.errors[:collection]).to eq(["nesting exceeds the allowed maximum nesting depth."])
-    end
-  end
-
-  describe 'parent is not nestable' do
-    let(:parent) { double(nestable?: false) }
-
-    it 'is not valid' do
-      subject.valid?
-      expect(subject.errors[:parent]).to eq(["is not nestable"])
-    end
-  end
-
-  describe 'child is not nestable' do
-    let(:child) { double(nestable?: false) }
-
-    it 'is not valid' do
-      subject.valid?
-      expect(subject.errors[:child]).to eq(["is not nestable"])
-    end
-  end
-
-  describe '#save' do
-    subject { form.save }
-
-    describe 'when not valid' do
-      before do
-        expect(form).to receive(:valid?).and_return(false)
-      end
-      it { is_expected.to be_falsey }
-      it 'does not even attempt to persist the relationship' do
-        expect(persistence_service).not_to receive(:persist_nested_collection_for)
-        subject
-      end
-    end
-    describe 'when valid' do
-      before do
-        expect(form).to receive(:valid?).and_return(true)
-      end
-      it "returns the result of the given persistence_service's call to persist_nested_collection_for" do
-        expect(persistence_service).to receive(:persist_nested_collection_for).with(parent: parent, child: child).and_return(:persisted)
-        subject
-      end
-    end
-  end
-
-  describe '#available_child_collections' do
-    subject { form.available_child_collections }
-
-    it 'delegates to the underlying query_service' do
-      expect(query_service).to receive(:available_child_collections).with(parent: parent, scope: context).and_return(:results)
-      expect(subject).to eq(:results)
-    end
-  end
-  describe '#available_parent_collections' do
-    subject { form.available_parent_collections }
-
-    it 'delegates to the underlying query_service' do
-      expect(query_service).to receive(:available_parent_collections).with(child: child, scope: context).and_return(:results)
-      expect(subject).to eq(:results)
-    end
-  end
-
-  describe '#validate_add' do
-    context 'when not nestable' do
-      let(:parent) { double(nestable?: false) }
-
-      it 'validates the parent cannnot contain nested subcollections' do
-        subject.validate_add
-        expect(subject.errors[:parent]).to eq(["cannot have child nested within it"])
-      end
-    end
-
-    context 'when nestable' do
-      context 'when at maximum nesting level' do
-        let(:parent) { double(nestable?: true) }
-        let(:nesting_depth_result) { false }
-
-        it 'validates the parent cannot have additional files nested' do
-          subject.validate_add
-          expect(subject.errors[:collection]).to eq(["nesting exceeds the allowed maximum nesting depth."])
-        end
-      end
-
-      context 'when valid' do
-        let(:parent) { double(nestable?: true) }
-
-        it 'validates the parent can contain nested subcollections' do
-          subject.validate_add
-          expect(subject.validate_add).to eq true
-        end
-      end
-    end
-  end
-
-  describe '#remove' do
-    subject { form.remove }
-
-    describe 'when not authorized' do
-      before do
-        expect(context).to receive(:can?).with(:edit, parent).and_return(false)
-      end
-
-      it 'does not even attempt to persist the relationship' do
-        expect(persistence_service).not_to receive(:remove_nested_relationship_for)
-        subject
-        expect(form.errors[:parent]).to eq(["permission is inadequate for removal of nesting relationship"])
-      end
-    end
-
-    describe 'when authorized' do
-      before do
-        expect(context).to receive(:can?).with(:edit, parent).and_return(true)
-      end
-
-      it "returns the result of the given persistence_service's call to remove_nested_relationship_for" do
-        expect(persistence_service).to receive(:remove_nested_relationship_for).with(parent: parent, child: child).and_return(:persisted)
-        subject
-      end
-    end
-  end
-end

data/spec/forms/hyrax/forms/file_manager_form_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Hyrax::Forms::FileManagerForm do
-  let(:work) { create(:work) }
-  let(:ability) { instance_double Ability }
-  let(:form) { described_class.new(work, ability) }
-
-  describe "#member_presenters" do
-    subject { form.member_presenters }
-
-    let(:factory) { instance_double(Hyrax::MemberPresenterFactory, member_presenters: result) }
-    let(:result) { double }
-
-    before do
-      allow(Hyrax::MemberPresenterFactory).to receive(:new).with(work, ability).and_return(factory)
-    end
-    it "is delegated to the MemberPresenterFactory" do
-      expect(subject).to eq result
-    end
-  end
-end

data/spec/forms/hyrax/forms/file_set_edit_form_spec.rb

@@ -1,53 +0,0 @@
-RSpec.describe Hyrax::Forms::FileSetEditForm do
-  subject { described_class.new(FileSet.new) }
-
-  describe '#terms' do
-    it 'returns a list' do
-      expect(subject.terms).to eq(
-        [:resource_type, :title, :creator, :contributor, :description, :keyword,
-         :license, :publisher, :date_created, :subject, :language, :identifier,
-         :based_near, :related_url,
-         :visibility_during_embargo, :visibility_after_embargo, :embargo_release_date,
-         :visibility_during_lease, :visibility_after_lease, :lease_expiration_date,
-         :visibility]
-      )
-    end
-
-    it "doesn't contain fields that users shouldn't be allowed to edit" do
-      # date_uploaded is reserved for the original creation date of the record.
-      expect(subject.terms).not_to include(:date_uploaded)
-    end
-  end
-
-  it 'initializes multivalued fields' do
-    expect(subject.title).to eq ['']
-  end
-
-  describe '.model_attributes' do
-    let(:params) do
-      ActionController::Parameters.new(
-        title: ['foo'],
-        "visibility" => "on-campus",
-        "visibility_during_embargo" => "restricted",
-        "embargo_release_date" => "2015-10-21",
-        "visibility_after_embargo" => "open",
-        "visibility_during_lease" => "open",
-        "lease_expiration_date" => "2015-10-21",
-        "visibility_after_lease" => "restricted"
-      )
-    end
-
-    subject { described_class.model_attributes(params) }
-
-    it 'changes only the title' do
-      expect(subject['title']).to eq ['foo']
-      expect(subject['visibility']).to eq('on-campus')
-      expect(subject['visibility_during_embargo']).to eq('restricted')
-      expect(subject['visibility_after_embargo']).to eq('open')
-      expect(subject['embargo_release_date']).to eq('2015-10-21')
-      expect(subject['visibility_during_lease']).to eq('open')
-      expect(subject['visibility_after_lease']).to eq('restricted')
-      expect(subject['lease_expiration_date']).to eq('2015-10-21')
-    end
-  end
-end

data/spec/forms/hyrax/forms/permission_template_form_spec.rb

@@ -1,599 +0,0 @@
-RSpec.describe Hyrax::Forms::PermissionTemplateForm do
-  let(:permission_template) { build(:permission_template) }
-  let(:form) { described_class.new(permission_template) }
-  let(:today) { Time.zone.today }
-  let(:admin_set) { create(:admin_set) }
-  let(:collection) { build(:collection_lw) }
-
-  subject { form }
-
-  it { is_expected.to delegate_method(:available_workflows).to(:model) }
-  it { is_expected.to delegate_method(:active_workflow).to(:model) }
-  it { is_expected.to delegate_method(:source_model).to(:model) }
-  it { is_expected.to delegate_method(:visibility).to(:model) }
-  it { is_expected.to delegate_method(:id).to(:source_model).with_prefix(:source) }
-  it { is_expected.to delegate_method(:reset_access_controls!).to(:source_model) }
-
-  it 'is expected to delegate method #active_workflow_id to #active_workflow#id' do
-    workflow = double(:workflow, id: 1234, active: true)
-    expect(permission_template).to receive(:active_workflow).and_return(workflow)
-    expect(form.workflow_id).to eq(workflow.id)
-  end
-
-  describe 'integration tests' do
-    let(:permission_template) { create(:permission_template, with_admin_set: true, with_workflows: true) }
-
-    subject do
-      form.update(
-        ActionController::Parameters.new(
-          access_grants_attributes: [
-            ActionController::Parameters.new(agent_type: "user",
-                                             agent_id: user.user_key,
-                                             access: access_level).permit!
-          ]
-        ).permit!
-      )
-    end
-
-    before do
-      # Create MANAGING role manually
-      Sipity::Role[Hyrax::RoleRegistry::MANAGING]
-    end
-
-    def count_template_accesses_for(user, access_level)
-      Hyrax::PermissionTemplateAccess.where(
-        agent_id: user.user_key,
-        access: access_level
-      ).count
-    end
-
-    def count_workflow_responsibilities_for(user)
-      Sipity::WorkflowResponsibility.where(agent: user.to_sipity_agent).count
-    end
-
-    it 'starts with no PTAs' do
-      expect(permission_template.access_grants).to be_empty
-    end
-
-    context 'with manager users' do
-      let(:user) { create(:user) }
-      let(:access_level) { 'manage' }
-
-      it 'adds the expected permission template accesses and workflow responsibilities' do
-        expect { subject }.to change {
-          count_template_accesses_for(user, access_level)
-        }.from(0).to(1).and change {
-          count_workflow_responsibilities_for(user)
-        }.from(0).to(6)
-      end
-
-      it 'removes workflow responsibilities' do
-        subject
-        expect do
-          form.remove_access!(
-            permission_template.access_grants.find_by(agent_id: user.user_key, access: access_level)
-          )
-        end.to change { count_workflow_responsibilities_for(user) }
-          .from(6).to(0)
-      end
-    end
-
-    context 'with depositor users' do
-      let(:user) { create(:user) }
-      let(:access_level) { 'deposit' }
-
-      it 'adds the expected permission template accesses and workflow responsibilities' do
-        expect { subject }.to change {
-          count_template_accesses_for(user, access_level)
-        }.from(0).to(1).and change {
-          count_workflow_responsibilities_for(user)
-        }.from(0).to(2)
-      end
-
-      it 'removes workflow responsibilities' do
-        subject
-        expect do
-          form.remove_access!(
-            permission_template.access_grants.find_by(agent_id: user.user_key, access: access_level)
-          )
-        end.to change { count_workflow_responsibilities_for(user) }
-          .from(2).to(0)
-      end
-    end
-
-    context 'with viewer users' do
-      let(:user) { create(:user) }
-      let(:access_level) { 'view' }
-
-      it 'adds the expected permission template accesses and workflow responsibilities' do
-        expect { subject }.to change {
-          count_template_accesses_for(user, access_level)
-        }.from(0).to(1).and change {
-          count_workflow_responsibilities_for(user)
-        }.by(0)
-      end
-
-      it 'does nothing (yet)' do
-        subject
-        expect do
-          form.remove_access!(
-            permission_template.access_grants.find_by(agent_id: user.user_key, access: access_level)
-          )
-        end.to change { count_workflow_responsibilities_for(user) }
-          .by(0)
-      end
-    end
-  end
-
-  describe "#update" do
-    subject { form.update(input_params) }
-
-    let(:grant_attributes) { [] }
-    let(:input_params) do
-      ActionController::Parameters.new(access_grants_attributes: grant_attributes).permit!
-    end
-    let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
-
-    let(:user) { create(:user) }
-    let(:user2) { create(:user) }
-    let(:user3) { create(:user) }
-
-    before do
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'user',
-             agent_id: user.user_key)
-      create(:permission_template_access,
-             :manage,
-             permission_template: permission_template,
-             agent_type: 'group',
-             agent_id: 'archivists')
-    end
-
-    context "with a user manager" do
-      let(:grant_attributes) do
-        [ActionController::Parameters.new(agent_type: "user",
-                                          agent_id: user2.user_key,
-                                          access: "manage").permit!]
-      end
-      let(:workflow) do
-        create(:workflow, permission_template: permission_template)
-      end
-
-      before do
-        role = Sipity::Role.create(name: 'approving')
-        workflow.workflow_roles.create(role: role)
-        # We are testing that this workflow role is removed
-        Hyrax::Workflow::PermissionGenerator.call(roles: role,
-                                                  workflow: workflow,
-                                                  agents: user3)
-        permission_template.update!(active_workflow: workflow)
-      end
-
-      def count_workflow_roles_for(user)
-        Hyrax::Workflow::PermissionQuery
-          .scope_processing_workflow_roles_for_user_and_workflow(user: user, workflow: workflow)
-          .size
-      end
-
-      it "adds edit_access to the AdminSet itself and grants workflow roles" do
-        expect { subject }.to change { permission_template.access_grants.count }.by(1)
-        expect(count_workflow_roles_for(user)).to eq 1
-        expect(count_workflow_roles_for(user2)).to eq 1
-        expect(count_workflow_roles_for(user3)).to eq 0
-        expect(admin_set.reload.edit_users).to match_array [user2.user_key, user.user_key]
-      end
-    end
-
-    context "with a group manager" do
-      let(:grant_attributes) do
-        [ActionController::Parameters.new(agent_type: "group",
-                                          agent_id: "bob",
-                                          access: "manage").permit!]
-      end
-
-      it "also adds edit_access to the AdminSet itself" do
-        expect { subject }.to change { permission_template.access_grants.count }.by(1)
-        expect(admin_set.reload.edit_groups).to match_array ['bob', 'archivists']
-      end
-    end
-
-    context "without a manager" do
-      let(:grant_attributes) do
-        [ActionController::Parameters.new(agent_type: "user",
-                                          agent_id: "bob",
-                                          access: "view").permit!]
-      end
-
-      it "doesn't adds edit_access to the AdminSet itself" do
-        expect { subject }.to change { permission_template.access_grants.count }.by(1)
-        expect(admin_set.reload.edit_users).to match_array [user.user_key] # MANAGE user added in before do
-      end
-    end
-
-    context "with visibility only" do
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY
-        ).permit!
-      end
-
-      it "updates the visibility, release_period=now, release_date=today" do
-        expect { subject }
-          .to change { permission_template.reload.visibility }.from(nil).to('open')
-                                                              .and change { permission_template.reload.release_period }.from(nil).to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY)
-        expect(permission_template.release_date).to eq(today)
-      end
-    end
-
-    context "with release 'varies', date specified" do
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: "",
-          release_varies: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE,
-          release_date: today + 1.year
-        ).permit!
-      end
-
-      it "sets release_period=before and release_date" do
-        expect { subject }.to change { permission_template.reload.release_period }.from(nil).to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE)
-        expect(permission_template.release_date).to eq(today + 1.year)
-      end
-    end
-
-    context "with release 'varies', embargo specified" do
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: "",
-          release_varies: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO,
-          release_embargo: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS
-        ).permit!
-      end
-
-      it "sets release_period to embargo period and release_date to 2 years from now" do
-        expect { subject }.to change { permission_template.reload.release_period }.from(nil).to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS)
-        expect(permission_template.release_date).to eq(today + 2.years)
-      end
-    end
-
-    context "with release 'fixed', date specified" do
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
-          release_date: today + 1.month
-        ).permit!
-      end
-
-      it "sets release_period=fixed and release_date" do
-        expect { subject }.to change { permission_template.reload.release_period }
-          .from(nil)
-          .to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED)
-        expect(permission_template.release_date).to eq(today + 1.month)
-      end
-    end
-
-    context "with modifying release_period from 'fixed' to 'no_delay'" do
-      let(:permission_template) do
-        create(:permission_template,
-               source_id: admin_set.id,
-               visibility: "open",
-               release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED,
-               release_date: today + 1.month)
-      end
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY
-        ).permit!
-      end
-
-      it "sets release_period=now, release_date=today" do
-        expect { subject }.to change { permission_template.reload.release_period }
-          .from(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED)
-          .to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY)
-        expect(permission_template.release_date).to eq(today)
-      end
-    end
-
-    context "with modifying release 'varies' from date specified to embargo specified" do
-      let(:permission_template) do
-        create(:permission_template,
-               source_id: admin_set.id,
-               visibility: "open",
-               release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE,
-               release_date: today + 1.month)
-      end
-      let(:input_params) do
-        ActionController::Parameters.new(
-          visibility: "open",
-          release_period: "",
-          release_varies: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO,
-          release_embargo: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS
-        ).permit!
-      end
-
-      it "sets release_period to embargo period, release_date to 2 years from now" do
-        expect { subject }.to change { permission_template.reload.release_period }
-          .from(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE)
-          .to(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS)
-        expect(permission_template.release_date).to eq(today + 2.years)
-      end
-    end
-
-    context "for a workflow change" do
-      let(:permission_template) { create(:permission_template, source_id: admin_set.id, with_active_workflow: true) }
-      let(:new_workflow) { create(:workflow, permission_template: permission_template, active: false) }
-      let(:input_params) do
-        ActionController::Parameters.new(
-          workflow_id: new_workflow.id
-        ).permit!
-      end
-
-      it "changes the workflow" do
-        expect { subject }.to change { permission_template.reload.active_workflow }.to(new_workflow)
-        expect(new_workflow.reload).to be_active
-      end
-    end
-  end
-
-  describe "#grant_workflow_roles" do
-    subject do
-      form.attributes = attributes
-      form.send(:grant_workflow_roles)
-    end
-
-    let(:attributes) { { workflow_id: workflow.id } }
-    let(:workflow) { create(:workflow, permission_template: permission_template, active: true) }
-    let(:user) { create(:user) }
-    let(:role1) { Sipity::Role.create!(name: 'hello') }
-    let(:role2) { Sipity::Role.create!(name: 'goodbye') }
-
-    let(:permission_template) do
-      create(:permission_template,
-             source_id: admin_set.id,
-             access_grants_attributes:
-               [{ agent_type: 'user',
-                  agent_id: user.user_key,
-                  access: 'manage' },
-                { agent_type: 'group',
-                  agent_id: 'librarians',
-                  access: 'manage' }])
-    end
-
-    before do
-      permission_template.clear_changes_information
-      workflow.workflow_roles.create!([{ role: role1 }, { role: role2 }])
-    end
-
-    context "when a new workflow has been chosen" do
-      it "gives the managers workflow roles" do
-        expect { subject }.to change { Sipity::WorkflowResponsibility.count }.by(4)
-      end
-    end
-
-    context "when a workflow is not changed" do
-      it "does nothing" do
-        subject # Setting up the subject to verify that when we call it again things don't change
-        expect { subject }.not_to change { Sipity::WorkflowResponsibility.count }
-      end
-    end
-  end
-
-  describe "#validate_visibility_combinations" do
-    let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
-
-    context "validate all release option attribute combinations" do
-      let(:visibility) { '' } # default values
-      let(:release_date) { nil }
-      let(:release_period) { '' }
-      let(:release_varies) { nil }
-      let(:release_embargo) { nil }
-      let(:error_code) { nil }
-      let(:attributes) do
-        {
-          visibility: visibility,
-          release_date: release_date,
-          release_period: release_period,
-          release_varies: release_varies,
-          release_embargo: release_embargo
-        }
-      end
-      let(:ac_params) do
-        ActionController::Parameters.new(attributes).permit!
-      end
-
-      RSpec.shared_examples 'valid attributes' do
-        it 'are accepted by #update' do
-          expect(form.update(ac_params)).to eq(content_tab: "visibility", updated: true)
-        end
-      end
-
-      RSpec.shared_examples 'invalid attributes' do
-        let(:response) { form.update(ac_params) }
-
-        it 'trigger error from #update' do
-          expect(response).to eq(content_tab: "visibility", updated: false, error_code: error_code)
-          expect(I18n.t(response[:error_code], scope: 'hyrax.admin.admin_sets.form.permission_update_errors')).not_to include('translation missing')
-        end
-      end
-
-      describe 'no delay' do
-        let(:release_period) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY }
-
-        it_behaves_like 'valid attributes'
-      end
-
-      describe 'varies, with depositor choice' do
-        let(:release_period) { '' }
-        let(:release_varies) { '' }
-
-        it_behaves_like 'valid attributes'
-      end
-
-      describe 'varies, with date selected' do
-        let(:release_date) { Time.zone.today + 2.months }
-        let(:release_varies) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE }
-
-        it_behaves_like 'valid attributes'
-      end
-
-      describe 'varies, with embargo selected' do
-        let(:release_varies) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO }
-        let(:release_embargo) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_2_YEARS }
-
-        it_behaves_like 'valid attributes'
-      end
-
-      describe 'fixed, with date selected' do
-        let(:release_date) { Time.zone.today + 2.months }
-        let(:release_period) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED }
-
-        it_behaves_like 'valid attributes'
-      end
-
-      describe 'varies, but no subsequent options' do
-        let(:release_period) { nil }
-        let(:error_code) { 'nothing' }
-
-        it_behaves_like 'invalid attributes'
-      end
-
-      describe 'varies, with date option but no date' do
-        let(:release_varies) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE }
-        let(:release_date) { '' }
-        let(:error_code) { 'no_date' }
-
-        it_behaves_like 'invalid attributes'
-      end
-
-      describe 'varies, with embargo option but no period' do
-        let(:release_varies) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO }
-        let(:release_embargo) { '' }
-        let(:error_code) { 'no_embargo' }
-
-        it_behaves_like 'invalid attributes'
-      end
-
-      describe 'fixed, with no date selected' do
-        let(:release_period) { Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_FIXED }
-        let(:release_date) { '' }
-        let(:error_code) { 'no_date' }
-
-        it_behaves_like 'invalid attributes'
-      end
-    end
-  end
-
-  describe "#select_release_varies_option" do
-    subject { form.send(:select_release_varies_option, permission_template) }
-
-    context "with release before date specified" do
-      let(:permission_template) do
-        create(:permission_template,
-               source_id: admin_set.id,
-               visibility: '',
-               release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE,
-               release_date: today + 1.month)
-      end
-
-      it "selects release_varies='before'" do
-        expect(form.release_varies).to eq(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE)
-        expect(form.release_embargo).to be_nil
-      end
-    end
-
-    context "with release embargo specified" do
-      let(:permission_template) do
-        create(:permission_template,
-               source_id: admin_set.id,
-               visibility: '',
-               release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR)
-      end
-
-      it "selects release_varies='embargo' and value in embargo selectbox" do
-        expect(form.release_varies).to eq(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO)
-        expect(form.release_embargo).to eq(Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR)
-      end
-    end
-
-    context "with release no-delay (now) selected" do
-      let(:permission_template) do
-        create(:permission_template,
-               source_id: admin_set.id,
-               visibility: '',
-               release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY)
-      end
-
-      it "selects neither varies option, nor embargo" do
-        expect(form.release_varies).to be_nil
-        expect(form.release_embargo).to be_nil
-      end
-    end
-  end
-
-  describe "#permission_template_update_params" do
-    let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
-
-    subject do
-      form.attributes = input_params
-      form.send(:permission_template_update_params)
-    end
-
-    context "with release varies by date selected" do
-      let(:input_params) do
-        ActionController::Parameters.new(visibility: '',
-                                         release_period: "",
-                                         release_varies: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE,
-                                         release_date: today + 1.month).permit!
-      end
-
-      it "updates params to release_period=before and keeps date" do
-        expect(subject).to eq ActionController::Parameters.new(
-          visibility: '',
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_BEFORE_DATE,
-          release_date: today + 1.month
-        ).permit!
-      end
-    end
-
-    context "with release varies by embargo selected" do
-      let(:input_params) do
-        ActionController::Parameters.new(visibility: '',
-                                         release_period: "",
-                                         release_varies: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_EMBARGO,
-                                         release_embargo: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR).permit!
-      end
-
-      it "updates params to release_period=1yr" do
-        expect(subject).to eq ActionController::Parameters.new(
-          visibility: '',
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_1_YEAR,
-          release_date: nil
-        ).permit!
-      end
-    end
-
-    context "with release no delay (now) selected, after filling out release_date" do
-      let(:input_params) do
-        ActionController::Parameters.new(visibility: '',
-                                         release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
-                                         release_varies: "",
-                                         release_embargo: "",
-                                         release_date: today + 1.month).permit!
-      end
-
-      it "updates params to release_period=1yr" do
-        expect(subject).to eq ActionController::Parameters.new(
-          visibility: '',
-          release_period: Hyrax::PermissionTemplate::RELEASE_TEXT_VALUE_NO_DELAY,
-          release_date: nil
-        ).permit!
-      end
-    end
-  end
-end