hyrax 2.9.6 → 3.0.0.pre.beta1

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

@@ -0,0 +1,196 @@
+RSpec.describe Hyrax::Forms::CollectionForm do
+  describe "#terms" do
+    subject { described_class.terms }
+
+    it do
+      is_expected.to eq [: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) }
+  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 [
+        :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) }
+    let(:parent_collection) { build(:collection) }
+    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 [{ 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) { create(:collection) }
+
+      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) { create(:collection, 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

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

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

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