hyrax 2.9.6 → 3.0.0.pre.beta1

data/spec/forms/hyrax/forms/work_form_spec.rb

@@ -0,0 +1,346 @@
+RSpec.describe Hyrax::Forms::WorkForm do
+  let(:work) { GenericWork.new }
+  let(:form) { described_class.new(work, nil, controller) }
+  let(:works) { [GenericWork.new, FileSet.new, GenericWork.new] }
+  let(:controller) { instance_double(Hyrax::GenericWorksController) }
+
+  # This class is an abstract class, so we have to set model_class
+  # TODO: merge with generic_work_form_spec
+  before do
+    allow(described_class).to receive(:model_class).and_return(GenericWork)
+    allow(form).to receive(:model_class).and_return(GenericWork)
+  end
+
+  describe "#version" do
+    before do
+      allow(work).to receive(:etag).and_return('123456')
+    end
+    subject { form.version }
+
+    it { is_expected.to eq '123456' }
+  end
+
+  describe "#select_files" do
+    let(:work) { create(:work_with_one_file) }
+    let(:title) { work.file_sets.first.title.first }
+    let(:file_id) { work.file_sets.first.id }
+
+    subject { form.select_files }
+
+    it { is_expected.to eq(title => file_id) }
+  end
+
+  describe '#member_of_collections' do
+    subject { form.member_of_collections }
+
+    before do
+      allow(controller).to receive(:params).and_return(add_works_to_collection: collection_id)
+    end
+
+    context 'when passed nil' do
+      let(:collection_id) { nil }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'when passed a string' do
+      let(:collection) { create(:collection) }
+      let(:collection_id) { collection.id }
+
+      it { is_expected.to match_array([collection]) }
+    end
+
+    context 'when member of other collections' do
+      let(:collection) { create(:collection) }
+      let(:collection_id) { collection.id }
+
+      before do
+        allow(work).to receive(:member_of_collections).and_return(['foo'])
+      end
+
+      it { is_expected.to match_array(['foo', collection]) }
+    end
+  end
+
+  describe "#[]" do
+    it 'has one element' do
+      expect(form['description']).to eq ['']
+    end
+  end
+
+  describe "#work_members" do
+    subject { form.work_members }
+
+    before do
+      allow(work).to receive(:members).and_return(works)
+    end
+
+    it "expects members that are works" do
+      expect(form.work_members.size).to eq(2)
+    end
+  end
+
+  describe ".build_permitted_params" do
+    subject { described_class.build_permitted_params }
+
+    context "without mediated deposit" do
+      it {
+        is_expected.to include(:add_works_to_collection,
+                               :version,
+                               :on_behalf_of,
+                               { permissions_attributes: [:type, :name, :access, :id, :_destroy] },
+                               based_near_attributes: [:id, :_destroy],
+                               member_of_collections_attributes: [:id, :_destroy],
+                               work_members_attributes: [:id, :_destroy])
+      }
+    end
+  end
+
+  describe ".model_attributes" do
+    let(:params) { ActionController::Parameters.new(attributes) }
+    let(:attributes) do
+      {
+        title: ['foo'],
+        description: [''],
+        visibility: 'open',
+        parent_id: '123',
+        representative_id: '456',
+        thumbnail_id: '789',
+        keyword: ['penguin'],
+        source: ['related'],
+        rights_statement: 'http://rightsstatements.org/vocab/InC-EDU/1.0/',
+        license: ['http://creativecommons.org/licenses/by/3.0/us/']
+      }
+    end
+
+    subject { described_class.model_attributes(params) }
+
+    it 'permits parameters' do
+      expect(subject['title']).to eq ['foo']
+      expect(subject['description']).to be_empty
+      expect(subject['visibility']).to eq 'open'
+      expect(subject['license']).to eq ['http://creativecommons.org/licenses/by/3.0/us/']
+      expect(subject['rights_statement']).to eq 'http://rightsstatements.org/vocab/InC-EDU/1.0/'
+      expect(subject['keyword']).to eq ['penguin']
+      expect(subject['source']).to eq ['related']
+    end
+
+    it 'excludes non-permitted params' do
+      expect(subject).not_to have_key 'parent_id'
+    end
+
+    context "when a user is granted edit access" do
+      let(:admin_set) { create(:admin_set) }
+
+      context "and a admin_set that allows grants has been selected" do
+        let(:attributes) { { admin_set_id: admin_set.id, permissions_attributes: [{ type: 'person', name: 'justin', access: 'edit' }] } }
+        let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
+        let!(:workflow) { create(:workflow, allows_access_grant: true, active: true, permission_template_id: permission_template.id) }
+
+        it do
+          is_expected.to eq ActionController::Parameters.new(admin_set_id: admin_set.id,
+                                                             permissions_attributes: [ActionController::Parameters.new(type: 'person', name: 'justin', access: 'edit')]).permit!
+        end
+      end
+
+      context "and no admin_set has been selected" do
+        let(:attributes) { { permissions_attributes: [{ type: 'person', name: 'justin', access: 'edit' }] } }
+
+        it { is_expected.to eq ActionController::Parameters.new.permit! }
+      end
+
+      context "and an admin_set that doesn't allow grants has been selected" do
+        let(:attributes) { { admin_set_id: admin_set.id, permissions_attributes: [{ type: 'person', name: 'justin', access: 'edit' }] } }
+        let(:permission_template) { create(:permission_template, source_id: admin_set.id) }
+        let!(:workflow) { create(:workflow, allows_access_grant: false, active: true, permission_template_id: permission_template.id) }
+
+        it { is_expected.to eq ActionController::Parameters.new(admin_set_id: admin_set.id).permit! }
+      end
+    end
+
+    context "without permissions being set" do
+      let(:attributes) { {} }
+
+      it { is_expected.to eq ActionController::Parameters.new.permit! }
+    end
+  end
+
+  describe "initialized fields" do
+    context "for :description" do
+      subject { form[:description] }
+
+      it { is_expected.to eq [''] }
+    end
+
+    context "for :embargo_release_date" do
+      subject { form[:embargo_release_date] }
+
+      it { is_expected.to be nil }
+    end
+  end
+
+  describe '#visibility' do
+    subject { form.visibility }
+
+    it { is_expected.to eq 'restricted' }
+  end
+
+  describe '#primary_terms' do
+    it 'contains the required fields' do
+      expect(form.primary_terms).to include(*form.required_fields)
+    end
+
+    context 'with a field that is not in terms' do
+      let(:bad_term) { :BadWorkFormSpecTerm }
+
+      before { form.class.required_fields += [bad_term] }
+      after  { form.class.required_fields -= [bad_term] }
+
+      it 'logs a warning' do
+        expect(Rails.logger).to receive(:warn).with(/#{bad_term}/)
+        form.primary_terms
+      end
+
+      it 'does not include the errant term' do
+        expect(form.primary_terms).not_to include bad_term
+      end
+    end
+  end
+
+  describe '#secondary_terms' do
+    it 'does not contain the primary terms' do
+      expect(form.secondary_terms).not_to include(*form.primary_terms)
+    end
+
+    context 'with a new non-primary term' do
+      let(:new_term) { :WorkFormSpecTerm }
+
+      before { form.class.terms += [new_term] }
+      after  { form.class.terms -= [new_term] }
+
+      it 'adds the term to secondary' do
+        expect(form.secondary_terms).to include new_term
+      end
+    end
+  end
+
+  describe '#human_readable_type' do
+    subject { form.human_readable_type }
+
+    it { is_expected.to eq 'Generic Work' }
+  end
+
+  describe "#open_access?" do
+    subject { form.open_access? }
+
+    it { is_expected.to be false }
+  end
+
+  describe "#authenticated_only_access?" do
+    subject { form.authenticated_only_access? }
+
+    it { is_expected.to be false }
+  end
+
+  describe "#open_access_with_embargo_release_date?" do
+    subject { form.open_access_with_embargo_release_date? }
+
+    it { is_expected.to be false }
+  end
+
+  describe "#private_access?" do
+    subject { form.private_access? }
+
+    it { is_expected.to be true }
+  end
+
+  describe "#member_ids" do
+    subject { form.member_ids }
+
+    it { is_expected.to eq work.member_ids }
+  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
+
+  describe "#embargo_release_date" do
+    let(:work) { create(:work, embargo_release_date: 5.days.from_now) }
+
+    subject { form.embargo_release_date }
+
+    it { is_expected.to eq work.embargo_release_date }
+  end
+
+  describe "#visibility_during_embargo" do
+    let(:work) { create(:work, visibility_during_embargo: 'authenticated') }
+
+    subject { form.visibility_during_embargo }
+
+    it { is_expected.to eq work.visibility_during_embargo }
+  end
+
+  describe "#visibility_after_embargo" do
+    let(:work) { create(:work, visibility_after_embargo: 'public') }
+
+    subject { form.visibility_after_embargo }
+
+    it { is_expected.to eq work.visibility_after_embargo }
+  end
+
+  describe "#lease_expiration_date" do
+    let(:work) { create(:work, lease_expiration_date: 2.days.from_now) }
+
+    subject { form.lease_expiration_date }
+
+    it { is_expected.to eq work.lease_expiration_date }
+  end
+
+  describe "#visibility_during_lease" do
+    let(:work) { create(:work, visibility_during_lease: 'authenticated') }
+
+    subject { form.visibility_during_lease }
+
+    it { is_expected.to eq work.visibility_during_lease }
+  end
+
+  describe "#visibility_after_lease" do
+    let(:work) { create(:work, visibility_after_lease: 'private') }
+
+    subject { form.visibility_after_lease }
+
+    it { is_expected.to eq work.visibility_after_lease }
+  end
+
+  describe ".workflow_for" do
+    subject { described_class.send(:workflow_for, admin_set_id: admin_set.id) }
+
+    context "when a active workflow is not found" do
+      let(:admin_set) { create(:admin_set, with_permission_template: true) }
+
+      it "raises a custom error" do
+        expect { subject }.to raise_error Hyrax::MissingWorkflowError
+      end
+    end
+    context "when a permission_template is not found" do
+      let(:admin_set) { create(:admin_set) }
+
+      it "raises an error" do
+        expect { subject }.to raise_error(/Missing permission template for AdminSet\(id:/)
+      end
+    end
+  end
+end

data/spec/forms/hyrax/forms/workflow_action_form_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe Hyrax::Forms::WorkflowActionForm do
+  let(:work) { create(:work) }
+  let(:sipity_entity) do
+    create(:sipity_entity, proxy_for_global_id: work.to_global_id.to_s, workflow_state_id: 2)
+  end
+  let(:user) { create(:user) }
+  let(:current_ability) { double(current_user: user) }
+  let(:form) do
+    described_class.new(current_ability: current_ability,
+                        work: work,
+                        attributes: { name: 'an_action', comment: 'a_comment' })
+  end
+
+  let(:an_action) do
+    instance_double(Sipity::WorkflowAction,
+                    resulting_workflow_state_id: 3,
+                    notifiable_contexts: [],
+                    triggered_methods: Sipity::Method.none)
+  end
+
+  context 'if the given user cannot perform the given action' do
+    before do
+      allow(PowerConverter).to receive(:convert_to_sipity_action).with('an_action', scope: sipity_entity.workflow).and_return(an_action)
+      expect(Hyrax::Workflow::PermissionQuery).to receive(:authorized_for_processing?).and_return(false)
+    end
+
+    describe '#valid?' do
+      subject { form.valid? }
+
+      it { is_expected.to be false }
+    end
+
+    describe '#save' do
+      subject { form.save }
+
+      it { is_expected.to be false }
+
+      it 'will not add a comment' do
+        expect { form.save }.not_to change { Sipity::Comment.count }
+      end
+
+      it 'will not send the #deliver_on_action_taken message to Hyrax::Workflow::NotificationService' do
+        expect(Hyrax::Workflow::NotificationService).not_to receive(:deliver_on_action_taken)
+        subject
+      end
+
+      it 'will not send the #handle_action_taken message to Hyrax::Workflow::ActionTakenService' do
+        expect(Hyrax::Workflow::ActionTakenService).not_to receive(:handle_action_taken)
+        subject
+      end
+    end
+  end
+
+  context 'if the given user can perform the given action' do
+    before do
+      allow(PowerConverter).to receive(:convert_to_sipity_action).with('an_action', scope: sipity_entity.workflow).and_return(an_action)
+      expect(Hyrax::Workflow::PermissionQuery).to receive(:authorized_for_processing?)
+        .and_return(true)
+    end
+
+    describe '#valid?' do
+      subject { form.valid? }
+
+      it { is_expected.to eq(true) }
+    end
+
+    describe '#save' do
+      before do
+        allow(work).to receive(:update_index)
+      end
+      subject { form.save }
+
+      it { is_expected.to be true }
+
+      context 'and the action has a resulting_workflow_state_id' do
+        it 'will update the state of the given work and index it' do
+          expect(work).to receive(:update_index)
+          expect { subject }.to change { sipity_entity.reload.workflow_state_id }.from(2).to(an_action.resulting_workflow_state_id)
+        end
+      end
+
+      context 'and the action does not have a resulting_workflow_state_id' do
+        let(:an_action) do
+          instance_double(Sipity::WorkflowAction,
+                          resulting_workflow_state_id: nil,
+                          notifiable_contexts: [],
+                          triggered_methods: Sipity::Method.none)
+        end
+
+        it 'will not update the state of the given work' do
+          expect { subject }.not_to change { sipity_entity.reload.workflow_state_id }
+        end
+      end
+
+      it 'will create the given comment for the entity' do
+        expect { subject }.to change { Sipity::Comment.count }.by(1)
+      end
+
+      it 'will send the #deliver_on_action_taken message to Hyrax::Workflow::NotificationService' do
+        expect(Hyrax::Workflow::NotificationService).to(
+          receive(:deliver_on_action_taken).with(entity: sipity_entity, comment: kind_of(Sipity::Comment), action: an_action, user: user)
+        )
+        subject
+      end
+
+      it 'will send the #handle_action_taken message to Hyrax::Workflow::ActionTakenService' do
+        expect(Hyrax::Workflow::ActionTakenService).to(
+          receive(:handle_action_taken).with(target: work, comment: kind_of(Sipity::Comment), action: an_action, user: user)
+        )
+        subject
+      end
+    end
+  end
+
+  context 'when no option is selected upon initialization' do
+    before do
+      sipity_entity
+    end
+    let(:form) do
+      described_class.new(current_ability: current_ability,
+                          work: work,
+                          attributes: { comment: '' })
+    end
+
+    it 'will be invalid' do
+      expect(form).not_to be_valid
+    end
+  end
+end

data/spec/forms/hyrax/forms/workflow_responsibility_form_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Hyrax::Forms::WorkflowResponsibilityForm do
+  let(:instance) { described_class.new }
+
+  describe "#initialize" do
+    let(:user) { create(:user) }
+    let(:instance) { described_class.new(user_id: user.id, workflow_role_id: 7) }
+
+    subject { instance.model_instance }
+
+    it "creates an agent and sets the workflow_role_id" do
+      expect(subject.agent).to be_kind_of Sipity::Agent
+      expect(subject.workflow_role_id).to eq 7
+    end
+  end
+
+  describe "#user_options" do
+    subject { instance.user_options }
+
+    it { is_expected.to eq User.all }
+  end
+
+  describe "#workflow_role_options" do
+    subject { instance.workflow_role_options }
+
+    let(:wf_role1) { instance_double(Sipity::WorkflowRole, id: 1) }
+    let(:wf_role2) { instance_double(Sipity::WorkflowRole, id: 2) }
+
+    before do
+      allow(Sipity::WorkflowRole).to receive(:all).and_return([wf_role1, wf_role2])
+      allow(Hyrax::Admin::WorkflowRolePresenter).to receive(:new)
+        .with(wf_role1)
+        .and_return(instance_double(Hyrax::Admin::WorkflowRolePresenter,
+                                    label: 'generic_work - foo'))
+      allow(Hyrax::Admin::WorkflowRolePresenter).to receive(:new)
+        .with(wf_role2)
+        .and_return(instance_double(Hyrax::Admin::WorkflowRolePresenter,
+                                    label: 'generic_work - bar'))
+    end
+    it { is_expected.to eq [['generic_work - bar', 2], ['generic_work - foo', 1]] }
+  end
+end

data/spec/forms/hyrax/generic_work_form_spec.rb

@@ -0,0 +1,127 @@
+# TODO: this should be merged with work_form_spec.rb
+RSpec.describe Hyrax::GenericWorkForm do
+  let(:work) { GenericWork.new }
+  let(:form) { described_class.new(work, nil, nil) }
+
+  describe "#required_fields" do
+    subject { form.required_fields }
+
+    it { is_expected.to eq [:title, :creator, :keyword, :rights_statement] }
+  end
+
+  describe "#primary_terms" do
+    subject { form.primary_terms }
+
+    it { is_expected.to eq [:title, :creator, :keyword, :rights_statement] }
+  end
+
+  describe "#secondary_terms" do
+    subject { form.secondary_terms }
+
+    it do
+      is_expected.not_to include(:title, :creator, :keyword,
+                                 :visibilty, :visibility_during_embargo,
+                                 :embargo_release_date, :visibility_after_embargo,
+                                 :visibility_during_lease, :lease_expiration_date,
+                                 :visibility_after_lease, :collection_ids)
+    end
+  end
+
+  describe "#[]" do
+    subject { form[term] }
+
+    context "for member_of_collection_ids" do
+      let(:term) { :member_of_collection_ids }
+
+      it { is_expected.to eq [] }
+
+      context "when the model has collection ids" do
+        before do
+          allow(work).to receive(:member_of_collection_ids).and_return(['col1', 'col2'])
+        end
+        # This allows the edit form to show collections the work is already a member of.
+        it { is_expected.to eq ['col1', 'col2'] }
+      end
+    end
+  end
+
+  describe '.model_attributes' do
+    let(:permission_template) { create(:permission_template, source_id: source_id) }
+    let!(:workflow) { create(:workflow, active: true, permission_template_id: permission_template.id) }
+    let(:source_id) { '123' }
+    let(:file_set) { create(:file_set) }
+    let(:params) do
+      ActionController::Parameters.new(
+        title: ['foo'],
+        description: [''],
+        visibility: 'open',
+        source_id: source_id,
+        representative_id: '456',
+        rendering_ids: [file_set.id],
+        thumbnail_id: '789',
+        keyword: ['penguin'],
+        license: ['http://creativecommons.org/licenses/by/3.0/us/'],
+        member_of_collection_ids: ['123456', 'abcdef']
+      )
+    end
+
+    subject { described_class.model_attributes(params) }
+
+    it 'permits parameters' do
+      expect(subject['title']).to eq ['foo']
+      expect(subject['description']).to be_empty
+      expect(subject['visibility']).to eq 'open'
+      expect(subject['license']).to eq ['http://creativecommons.org/licenses/by/3.0/us/']
+      expect(subject['keyword']).to eq ['penguin']
+      expect(subject['member_of_collection_ids']).to eq ['123456', 'abcdef']
+      expect(subject['rendering_ids']).to eq [file_set.id]
+    end
+
+    context '.model_attributes' do
+      let(:params) do
+        ActionController::Parameters.new(
+          title: [''],
+          description: [''],
+          keyword: [''],
+          license: [''],
+          member_of_collection_ids: [''],
+          on_behalf_of: 'Melissa'
+        )
+      end
+
+      it 'removes blank parameters' do
+        expect(subject['title']).to be_empty
+        expect(subject['description']).to be_empty
+        expect(subject['license']).to be_empty
+        expect(subject['keyword']).to be_empty
+        expect(subject['member_of_collection_ids']).to be_empty
+        expect(subject['on_behalf_of']).to eq 'Melissa'
+      end
+    end
+  end
+
+  describe "#visibility" do
+    subject { form.visibility }
+
+    it { is_expected.to eq 'restricted' }
+  end
+
+  subject { form }
+
+  it { is_expected.to delegate_method(:on_behalf_of).to(:model) }
+  it { is_expected.to delegate_method(:depositor).to(:model) }
+  it { is_expected.to delegate_method(:permissions).to(:model) }
+
+  describe "#agreement_accepted" do
+    subject { form.agreement_accepted }
+
+    it { is_expected.to eq false }
+  end
+
+  context "on a work already saved" do
+    before { allow(work).to receive(:new_record?).and_return(false) }
+    it "defaults deposit agreement to true" do
+      expect(form.agreement_accepted).to eq(true)
+    end
+  end
+end