hydra-works 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dccbd98c61c1d4f18a6638c637c52adb8414c39b
-  data.tar.gz: 898863dcf45f52862fddebd401c31d31a7384ee2
+  metadata.gz: fc76ae65e10c75f045b933e2b8de237292821b2d
+  data.tar.gz: 20c76bd9fb5e0002a74f279efa932ab0685618e5
 SHA512:
-  metadata.gz: 5b895ae5c78efa14c537173445f3d8b70304e4ff5462912839ffae55bb96162c867066b15c55d0315cd7de2146da6bcf911f27c3a7b2502fd0228a05bf532d80
-  data.tar.gz: 526f699b440f37454b043a1e8127c93e42ff31a404ec9c487f0eeb15471feeda07abaf02aea2382e063360a25c06962a9d3bef79bc61107573ac6d8b74717838
+  metadata.gz: 7e97285baab41bb01e5ab16541057e6a50fee7630eb48daeb92eb8d7d64ef3cfd50878520533e1ee7e34fe6b5f74b8ad015b7756a99661aa9cd234bdbc0401e6
+  data.tar.gz: 35363e268e45beaf3331bd7976ad99b8a269850e8a51ef4c00380f98b6f9b8e9526fc3244a59ceb8f79fc0a51b9d36e3ebbe13bb3853f461d0396370a035b911

data/lib/hydra/works/models/concerns/file_set/mime_types.rb

@@ -28,16 +28,6 @@ module Hydra::Works
       false
     end
 
-    def file_format
-      if mime_type.present? && format_label.present?
-        "#{mime_type.split('/').last} (#{format_label.join(', ')})"
-      elsif mime_type.present?
-        mime_type.split('/').last
-      elsif format_label.present?
-        format_label
-      end
-    end
-
     module ClassMethods
       def image_mime_types
         ['image/png', 'image/jpeg', 'image/jpg', 'image/jp2', 'image/bmp', 'image/gif', 'image/tiff']

data/lib/hydra/works/models/concerns/file_set_behavior.rb

@@ -19,6 +19,8 @@ module Hydra::Works
       include Hydra::Works::Derivatives
       include Hydra::Works::MimeTypes
       include Hydra::Works::VersionedContent
+
+      before_destroy :remove_from_works
     end
 
     # @return [Boolean] whether this instance is a Hydra::Works Collection.
@@ -39,5 +41,15 @@ module Hydra::Works
     def in_works
       ordered_by.select { |parent| parent.class.included_modules.include?(Hydra::Works::WorkBehavior) }.to_a
     end
+
+    private
+
+      def remove_from_works
+        in_works.each do |parent|
+          parent.ordered_members.delete(self) # Delete the list node
+          parent.members.delete(self) # Delete the indirect container Proxy
+          parent.save! # record the changes to the ordered members
+        end
+      end
   end
 end

data/lib/hydra/works/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module Works
-    VERSION = '0.5.0'
+    VERSION = '0.6.0'
   end
 end

data/spec/hydra/works/models/collection_spec.rb

@@ -1,229 +1,87 @@
 require 'spec_helper'
 
 describe Hydra::Works::Collection do
-  subject { described_class.new }
+  let(:collection) { described_class.new }
 
   let(:collection1) { described_class.new }
-  let(:collection2) { described_class.new }
-  let(:collection3) { described_class.new }
-  let(:collection4) { described_class.new }
-
   let(:generic_work1) { Hydra::Works::GenericWork.new }
-  let(:generic_work2) { Hydra::Works::GenericWork.new }
-  let(:generic_work3) { Hydra::Works::GenericWork.new }
-  let(:generic_work4) { Hydra::Works::GenericWork.new }
 
   describe '#collections' do
     it 'returns empty array when only works are aggregated' do
-      subject.ordered_members << generic_work1
-      subject.ordered_members << generic_work2
-      expect(subject.collections).to eq []
+      collection.ordered_members << generic_work1
+      expect(collection.collections).to eq []
     end
 
     context 'with other collections & works' do
+      let(:collection2) { described_class.new }
       before do
-        subject.ordered_members << collection1
-        subject.ordered_members << collection2
-        subject.ordered_members << generic_work1
-        subject.ordered_members << generic_work2
+        collection.ordered_members << collection1
+        collection.ordered_members << collection2
+        collection.ordered_members << generic_work1
       end
 
       it 'returns only collections' do
-        expect(subject.ordered_collections).to eq [collection1, collection2]
+        expect(collection.ordered_collections).to eq [collection1, collection2]
       end
     end
   end
 
   describe '#works' do
-    it 'returns empty array when only collections are aggregated' do
-      subject.ordered_members << collection1
-      subject.ordered_members << collection2
-      expect(subject.ordered_works). to eq []
+    subject { collection.works }
+    context "when only collections are aggregated" do
+      it 'returns empty array when only collections are aggregated' do
+        collection.ordered_members << collection1
+        expect(subject).to eq []
+      end
     end
 
     context 'with collections and generic works' do
+      let(:generic_work2) { Hydra::Works::GenericWork.new }
       before do
-        subject.ordered_members << collection1
-        subject.ordered_members << collection2
-        subject.ordered_members << generic_work1
-        subject.ordered_members << generic_work2
+        collection.ordered_members << collection1
+        collection.ordered_members << generic_work1
+        collection.ordered_members << generic_work2
       end
 
       it 'returns only generic works' do
-        expect(subject.ordered_works). to eq [generic_work1, generic_work2]
+        expect(subject).to eq [generic_work1, generic_work2]
       end
     end
   end
 
-  describe "#ordered_work_ids" do
-    it "returns IDs of ordered works" do
-      subject.ordered_members << generic_work1
-      expect(subject.ordered_work_ids).to eq [generic_work1.id]
+  describe '#ordered_works' do
+    subject { collection.ordered_works }
+    context "when only collections are aggregated" do
+      it 'returns empty array when only collections are aggregated' do
+        collection.ordered_members << collection1
+        expect(subject).to eq []
+      end
     end
-  end
-
-  describe '#related_objects' do
-    let(:generic_file1) { Hydra::Works::FileSet.new }
-    let(:object1) { Hydra::PCDM::Object.new }
-    let(:object2) { Hydra::PCDM::Object.new }
 
     context 'with collections and generic works' do
+      let(:generic_work2) { Hydra::Works::GenericWork.new }
       before do
-        subject.ordered_members << collection1
-        subject.ordered_members << collection2
-        subject.ordered_members << generic_work1
-      end
-
-      it 'returns empty array when only collections and generic works are aggregated' do
-        expect(subject.related_objects).to eq []
+        collection.ordered_members << collection1
+        collection.ordered_members << generic_work1
+        collection.ordered_members << generic_work2
       end
 
-      it 'returns only related objects' do
-        subject.related_objects << object2
-        expect(subject.related_objects).to eq [object2]
-      end
-
-      it 'returns related objects of various types' do
-        subject.related_objects << generic_work2
-        subject.related_objects << generic_file1
-        subject.related_objects << object1
-        subject.save
-        subject.reload
-        expect(subject.related_objects.include? object1).to be true
-        expect(subject.related_objects.include? generic_work2).to be true
-        expect(subject.related_objects.include? generic_file1).to be true
-        expect(subject.related_objects.size).to eq 3
-      end
-    end
-  end
-
-  describe '#related_objects <<' do
-    context 'with acceptable related objects' do
-      let(:object1) { Hydra::PCDM::Object.new }
-      let(:object2) { Hydra::PCDM::Object.new }
-      let(:generic_file1) { Hydra::Works::FileSet.new }
-
-      it 'adds various types of related objects to collection' do
-        subject.related_objects << generic_work1
-        subject.related_objects << generic_file1
-        subject.related_objects << object1
-        subject.save
-        subject.reload
-        expect(subject.related_objects.include? generic_work1).to be true
-        expect(subject.related_objects.include? generic_file1).to be true
-        expect(subject.related_objects.include? object1).to be true
-        expect(subject.related_objects.size).to eq 3
-      end
-
-      context 'with collections and works' do
-        before do
-          subject.ordered_members << collection1
-          subject.ordered_members << collection2
-          subject.ordered_members << generic_work1
-          subject.ordered_members << generic_work2
-          subject.related_objects << object1
-        end
-
-        it 'adds a related object to collection with collections and works' do
-          subject.related_objects << object2
-          subject.save
-          subject.reload
-          expect(subject.related_objects.include? object1).to be true
-          expect(subject.related_objects.include? object2).to be true
-          expect(subject.related_objects.size).to eq 2
-        end
-      end
-    end
-
-    context 'with unacceptable child related objects' do
-      let(:pcdm_collection1) { Hydra::PCDM::Collection.new }
-      let(:pcdm_file1)       { Hydra::PCDM::File.new }
-      let(:non_PCDM_object)  { "I'm not a PCDM object" }
-      let(:af_base_object)   { ActiveFedora::Base.new }
-
-      it 'does not aggregate Hydra::Works::Collection in related objects aggregation' do
-        expect { subject.related_objects << collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::Works::Collection:.*> is not a PCDM object./)
-      end
-
-      it 'does not aggregate Hydra::PCDM::Collections in related objects aggregation' do
-        expect { subject.related_objects << pcdm_collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.* is not a PCDM object./)
-      end
-
-      it 'does not aggregate Hydra::PCDM::Files in related objects aggregation' do
-        expect { subject.related_objects << pcdm_file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got Hydra::PCDM::File.*/)
-      end
-
-      it 'does not aggregate non-PCDM objects in related objects aggregation' do
-        expect { subject.related_objects << non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
-      end
-
-      it 'does not aggregate AF::Base objects in related objects aggregation' do
-        expect { subject.related_objects << af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* is not a PCDM object./)
-      end
-    end
-
-    context 'with invalid behaviors' do
-      let(:object1) { Hydra::PCDM::Object.new }
-      let(:object2) { Hydra::PCDM::Object.new }
-
-      it 'does not allow related objects to repeat' do
-        skip 'skipping this test because issue pcdm#92 needs to be addressed' do
-          subject.related_objects << object1
-          subject.related_objects << object2
-          subject.related_objects << object1
-          related_objects = subject.related_objects
-          expect(related_objects.include? object1).to be true
-          expect(related_objects.include? object2).to be true
-          expect(related_objects.size).to eq 2
-        end
+      it 'returns only generic works' do
+        expect(subject).to eq [generic_work1, generic_work2]
       end
     end
   end
 
-  describe '#related_objects.delete' do
-    let(:related_object1) { Hydra::PCDM::Object.new }
-    let(:related_work2)   { Hydra::Works::GenericWork.new }
-    let(:related_file3)   { Hydra::Works::FileSet.new }
-    let(:related_object4) { Hydra::PCDM::Object.new }
-    let(:related_work5)   { Hydra::Works::GenericWork.new }
-
-    context 'when multiple related objects' do
-      before do
-        subject.related_objects << related_object1
-        subject.related_objects << related_work2
-        subject.members << collection2
-        subject.members << generic_work1
-        subject.related_objects << related_file3
-        subject.related_objects << related_object4
-        subject.members << collection1
-        subject.related_objects << related_work5
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4, related_work5]
-      end
-
-      it 'removes first related object' do
-        expect(subject.related_objects.delete related_object1).to eq [related_object1]
-        expect(subject.related_objects).to eq [related_work2, related_file3, related_object4, related_work5]
-        expect(subject.collections).to eq [collection2, collection1]
-        expect(subject.works). to eq [generic_work1]
-      end
-
-      it 'removes last related object' do
-        expect(subject.related_objects.delete related_work5).to eq [related_work5]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4]
-        expect(subject.collections).to eq [collection2, collection1]
-        expect(subject.works). to eq [generic_work1]
-      end
-
-      it 'removes middle related object' do
-        expect(subject.related_objects.delete related_file3).to eq [related_file3]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_object4, related_work5]
-        expect(subject.collections).to eq [collection2, collection1]
-        expect(subject.works). to eq [generic_work1]
-      end
+  describe "#ordered_work_ids" do
+    subject { collection.ordered_work_ids }
+    it "returns IDs of ordered works" do
+      collection.ordered_members << generic_work1
+      expect(subject).to eq [generic_work1.id]
     end
   end
 
-  describe 'Related objects' do
+  describe '#related_objects' do
+    subject { collection.related_objects }
     let(:object) { Hydra::PCDM::Object.new }
     let(:collection) { described_class.new }
 
@@ -231,22 +89,16 @@ describe Hydra::Works::Collection do
       collection.related_objects = [object]
     end
 
-    it 'persists' do
-      expect(collection.related_objects).to eq [object]
-    end
+    it { is_expected.to eq [object] }
   end
 
-  describe 'should have parent collection accessors' do
+  describe "#in_collections" do
     before do
-      collection1.ordered_members << collection2
+      collection1.ordered_members << collection
       collection1.save
     end
 
-    it 'has parents' do
-      expect(collection2.member_of).to eq [collection1]
-    end
-    it 'has a parent collection' do
-      expect(collection2.in_collections).to eq [collection1]
-    end
+    subject { collection.in_collections }
+    it { is_expected.to eq [collection1] }
   end
 end

data/spec/hydra/works/models/concerns/file_set/mime_types_spec.rb

@@ -53,22 +53,4 @@ describe Hydra::Works::MimeTypes do
       expect(subject.collection?).to be false
     end
   end
-
-  describe '#file_format?' do
-    it 'handles both mime and format_label' do
-      allow(subject).to receive(:mime_type).and_return('image/png')
-      allow(subject).to receive(:format_label).and_return(['Portable Network Graphics'])
-      expect(subject.file_format).to eq 'png (Portable Network Graphics)'
-    end
-    it 'handles just mime type' do
-      allow(subject).to receive(:mime_type).and_return('image/png')
-      allow(subject).to receive(:format_label).and_return([])
-      expect(subject.file_format).to eq 'png'
-    end
-    it 'handles just format_label' do
-      allow(subject).to receive(:mime_type).and_return('')
-      allow(subject).to receive(:format_label).and_return(['Portable Network Graphics'])
-      expect(subject.file_format).to eq ['Portable Network Graphics']
-    end
-  end
 end

data/spec/hydra/works/models/file_set_spec.rb

@@ -1,223 +1,57 @@
 require 'spec_helper'
 
 describe Hydra::Works::FileSet do
-  let(:generic_file1) { described_class.new }
+  let(:file_set) { described_class.new }
 
   describe 'Related objects' do
     let(:object1) { Hydra::PCDM::Object.new }
 
     before do
-      generic_file1.related_objects = [object1]
+      file_set.related_objects = [object1]
     end
 
     it 'persists' do
-      expect(generic_file1.related_objects).to eq [object1]
+      expect(file_set.related_objects).to eq [object1]
     end
   end
 
   describe '#files' do
-    let(:object) { described_class.create }
-    let(:file1) { object.files.build }
-    let(:file2) { object.files.build }
+    let(:file1) { file_set.files.build }
+    let(:file2) { file_set.files.build }
 
     before do
+      file_set.save!
       file1.content = "I'm a file"
       file2.content = 'I am too'
-      object.save!
+      file_set.save!
     end
 
-    subject { described_class.find(object.id).files }
+    subject { described_class.find(file_set.id).files }
 
     it { is_expected.to eq [file1, file2] }
   end
 
-  describe 'add related object' do
-    let(:subject) { described_class.new }
-
-    describe 'begin test' do
-      context 'with acceptable related objects' do
-        let(:object1) { Hydra::PCDM::Object.create }
-        let(:object2) { Hydra::PCDM::Object.new }
-        let(:generic_work1) { Hydra::Works::GenericWork.create }
-        let(:generic_work2) { Hydra::Works::GenericWork.new }
-        let(:generic_file1) { described_class.create }
-
-        it 'adds various types of related objects to generic_file' do
-          subject.related_objects << generic_work1
-          subject.related_objects << generic_file1
-          subject.related_objects << object1
-          subject.save
-          subject.reload
-          related_objects = subject.related_objects
-          expect(related_objects.include? generic_work1).to be true
-          expect(related_objects.include? generic_file1).to be true
-          expect(related_objects.include? object1).to be true
-          expect(related_objects.size).to eq 3
-        end
-
-        context 'with files and generic_files' do
-          let(:file1) { subject.files.build }
-          let(:file2) { subject.files.build }
-
-          before do
-            subject.save
-            file1.content = "I'm a file"
-            file2.content = 'I am too'
-            subject.related_objects << object1
-          end
-
-          it 'adds a related object to a generic_file with files and generic_files' do
-            subject.related_objects << object2
-            subject.save
-            subject.reload
-            related_objects = subject.related_objects
-            expect(related_objects.include? object1).to be true
-            expect(related_objects.include? object2).to be true
-            expect(related_objects.size).to eq 2
-          end
-        end
-      end
-
-      context 'with unacceptable child related objects' do
-        let(:collection1)      { Hydra::Works::Collection.new }
-        let(:pcdm_collection1) { Hydra::PCDM::Collection.new }
-        let(:pcdm_file1)       { Hydra::PCDM::File.new }
-        let(:non_PCDM_object)  { "I'm not a PCDM object" }
-        let(:af_base_object)   { ActiveFedora::Base.new }
-
-        let(:error_message) { 'child_related_object must be a pcdm object' }
-
-        it 'does not aggregate Hydra::Works::Collection in related objects aggregation' do
-          expect { subject.related_objects << collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::Works::Collection:.*> is not a PCDM object./)
-        end
-
-        it 'does not aggregate Hydra::PCDM::Collections in related objects aggregation' do
-          expect { subject.related_objects << pcdm_collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.*> is not a PCDM object./)
-        end
-
-        it 'does not aggregate Hydra::PCDM::Files in related objects aggregation' do
-          expect { subject.related_objects << pcdm_file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got Hydra::PCDM::File.*/)
-        end
-
-        it 'does not aggregate non-PCDM objects in related objects aggregation' do
-          expect { subject.related_objects << non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
-        end
-
-        it 'does not aggregate AF::Base objects in related objects aggregation' do
-          expect { subject.related_objects << af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* is not a PCDM object./)
-        end
-      end
-
-      context 'with invalid behaviors' do
-        let(:object1) { Hydra::PCDM::Object.new }
-        let(:object2) { Hydra::PCDM::Object.new }
-
-        it 'does not allow related objects to repeat' do
-          skip 'skipping this test because issue pcdm#92 needs to be addressed' do
-            subject.related_objects << object1
-            subject.related_objects << object2
-            subject.related_objects << object1
-            subject.save
-            subject.reload
-            related_objects = subject.related_objects
-            expect(related_objects.include? object1).to be true
-            expect(related_objects.include? object2).to be true
-            expect(related_objects.size).to eq 2
-          end
-        end
-      end
-    end
-  end
-
-  describe 'get related objects from generic file' do
-    subject { described_class.new }
-
-    let(:object1) { Hydra::PCDM::Object.new }
-    let(:object2) { Hydra::PCDM::Object.new }
-
-    let(:generic_work1) { Hydra::Works::GenericWork.new }
-    let(:generic_file1) { described_class.new }
-
-    context 'with generic files' do
-      it 'returns empty array when only generic files are aggregated' do
-        expect(subject.related_objects).to eq []
-      end
-
-      it 'returns related objects' do
-        subject.related_objects << object2
-        expect(subject.related_objects).to eq [object2]
-      end
-
-      it 'returns related objects of various types' do
-        subject.related_objects << generic_work1
-        subject.related_objects << generic_file1
-        subject.related_objects << object1
-        subject.save
-        subject.reload
-        related_objects = subject.related_objects
-        expect(related_objects.include? object1).to be true
-        expect(related_objects.include? generic_work1).to be true
-        expect(related_objects.include? generic_file1).to be true
-        expect(related_objects.size).to eq 3
-      end
-    end
-  end
-
-  describe 'remove related object from related object' do
-    subject { described_class.new }
-
-    let(:related_object1) { Hydra::PCDM::Object.new }
-    let(:related_work2)   { Hydra::Works::GenericWork.new }
-    let(:related_file3)   { described_class.new }
-    let(:related_object4) { Hydra::PCDM::Object.new }
-    let(:related_work5)   { Hydra::Works::GenericWork.new }
-
-    let(:generic_file1) { described_class.new }
-    let(:generic_file2) { described_class.new }
-
-    context 'when multiple related objects' do
-      before do
-        subject.related_objects << related_object1
-        subject.related_objects << related_work2
-        subject.related_objects << related_file3
-        subject.related_objects << related_object4
-        subject.related_objects << related_work5
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4, related_work5]
-      end
-
-      it 'removes first related object' do
-        expect(subject.related_objects.delete related_object1).to eq [related_object1]
-        expect(subject.related_objects).to eq [related_work2, related_file3, related_object4, related_work5]
-      end
-
-      it 'removes last related object' do
-        expect(subject.related_objects.delete related_work5).to eq [related_work5]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4]
-      end
-
-      it 'removes middle related object' do
-        expect(subject.related_objects.delete related_file3).to eq [related_file3]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_object4, related_work5]
-      end
+  describe '#in_works' do
+    subject { file_set.in_works }
+    let(:generic_work) { Hydra::Works::GenericWork.create }
+    before do
+      generic_work.ordered_members << file_set
+      generic_work.save
     end
 
-    # Assuming this context not needed because unacceptable related objects
-    # can't be added.
-    # context 'with unacceptable related object' do
+    it { is_expected.to eq [generic_work] }
   end
 
-  describe 'should have parent work accessors' do
-    let(:generic_work1) { Hydra::Works::GenericWork.create }
+  describe '#destroy' do
+    let(:generic_work) { Hydra::Works::GenericWork.create }
     before do
-      generic_work1.ordered_members << generic_file1
-      generic_work1.save
+      generic_work.ordered_members << file_set
+      generic_work.save
     end
 
-    it 'has parents' do
-      expect(generic_file1.member_of).to eq [generic_work1]
-    end
-    it 'has a parent work' do
-      expect(generic_file1.in_works).to eq [generic_work1]
+    it "Removes the proxy, the list_node and the FileSet" do
+      expect { file_set.destroy }.to change { ActiveFedora::Aggregation::Proxy.count }.by(-1)
+        .and change { generic_work.reload.ordered_member_proxies.to_a.length }.by(-1)
     end
   end
 end

data/spec/hydra/works/models/generic_work_spec.rb

@@ -207,153 +207,6 @@ describe Hydra::Works::GenericWork do
     end
   end
 
-  describe '#related_objects' do
-    context 'with acceptable related objects' do
-      it 'adds various types of related objects to generic_work' do
-        subject.related_objects << generic_work1
-        subject.related_objects << file_set1
-        subject.related_objects << object1
-        subject.save
-        subject.reload
-        expect(subject.related_objects.include? generic_work1).to be true
-        expect(subject.related_objects.include? file_set1).to be true
-        expect(subject.related_objects.include? object1).to be true
-        expect(subject.related_objects.size).to eq 3
-      end
-
-      context 'with works and file_sets' do
-        before do
-          subject.ordered_file_sets << file_set1
-          subject.ordered_file_sets << file_set2
-          subject.ordered_works << generic_work1
-          subject.ordered_works << generic_work2
-          subject.related_objects << object1
-        end
-
-        it 'adds a related object to file_set with works and file_sets' do
-          subject.related_objects << object2
-          subject.save
-          subject.reload
-          expect(subject.related_objects.include? object1).to be true
-          expect(subject.related_objects.include? object2).to be true
-          expect(subject.related_objects.size).to eq 2
-        end
-      end
-    end
-
-    context 'with unacceptable child related objects' do
-      let(:collection1)      { Hydra::Works::Collection.new }
-      let(:pcdm_collection1) { Hydra::PCDM::Collection.new }
-      let(:pcdm_file1)       { Hydra::PCDM::File.new }
-      let(:non_PCDM_object)  { "I'm not a PCDM object" }
-      let(:af_base_object)   { ActiveFedora::Base.new }
-
-      let(:error_message) { 'child_related_object must be a pcdm object' }
-
-      it 'does not aggregate Hydra::Works::Collection in related objects aggregation' do
-        expect { subject.related_objects << collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::Works::Collection:.*> is not a PCDM object./)
-      end
-
-      it 'does not aggregate Hydra::PCDM::Collections in related objects aggregation' do
-        expect { subject.related_objects << pcdm_collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.*> is not a PCDM object./)
-      end
-
-      it 'does not aggregate Hydra::PCDM::Files in related objects aggregation' do
-        expect { subject.related_objects << pcdm_file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got Hydra::PCDM::File.*/)
-      end
-
-      it 'does not aggregate non-PCDM objects in related objects aggregation' do
-        expect { subject.related_objects << non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
-      end
-
-      it 'does not aggregate AF::Base objects in related objects aggregation' do
-        expect { subject.related_objects << af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base:.*> is not a PCDM object./)
-      end
-    end
-
-    context 'with invalid bahaviors' do
-      it 'does not allow related objects to repeat' do
-        skip 'skipping this test because issue pcdm#92 needs to be addressed' do
-          subject.related_objects << object1
-          subject.related_objects << object2
-          subject.related_objects << object1
-          expect(subject.related_objects.include? object1).to be true
-          expect(subject.related_objects.include? object2).to be true
-          expect(subject.related_objects.size).to eq 2
-        end
-      end
-    end
-  end
-
-  describe '#related_objects <<' do
-    context 'with file sets and works' do
-      before do
-        subject.ordered_members << generic_work1
-        subject.ordered_members << generic_work1
-        subject.ordered_members << file_set1
-      end
-
-      it 'returns empty array when only generic files and generic works are aggregated' do
-        expect(subject.related_objects).to eq []
-      end
-
-      it 'returns only related objects' do
-        subject.related_objects << object2
-        expect(subject.related_objects).to eq [object2]
-      end
-
-      it 'returns related objects of various types' do
-        subject.related_objects << generic_work2
-        subject.related_objects << file_set1
-        subject.related_objects << object1
-        expect(subject.related_objects).to eq [generic_work2, file_set1, object1]
-        expect(subject.related_objects.size).to eq 3
-      end
-    end
-  end
-
-  describe '#related_objects.delete' do
-    context 'when multiple related objects' do
-      let(:related_object1) { Hydra::PCDM::Object.new }
-      let(:related_work2) { described_class.new }
-      let(:related_file3) { Hydra::Works::FileSet.new }
-      let(:related_object4) { Hydra::PCDM::Object.new }
-      let(:related_work5) { described_class.new }
-      before do
-        subject.related_objects << related_object1
-        subject.related_objects << related_work2
-        subject.ordered_members << generic_work2
-        subject.ordered_members << file_set1
-        subject.related_objects << related_file3
-        subject.related_objects << related_object4
-        subject.ordered_members << generic_work1
-        subject.related_objects << related_work5
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4, related_work5]
-      end
-
-      it 'removes first related object' do
-        expect(subject.related_objects.delete related_object1).to eq [related_object1]
-        expect(subject.related_objects).to eq [related_work2, related_file3, related_object4, related_work5]
-        expect(subject.ordered_works).to eq [generic_work2, generic_work1]
-        expect(subject.ordered_file_sets).to eq [file_set1]
-      end
-
-      it 'removes last related object' do
-        expect(subject.related_objects.delete related_work5).to eq [related_work5]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4]
-        expect(subject.ordered_works).to eq [generic_work2, generic_work1]
-        expect(subject.ordered_file_sets).to eq [file_set1]
-      end
-
-      it 'removes middle related object' do
-        expect(subject.related_objects.delete related_file3).to eq [related_file3]
-        expect(subject.related_objects).to eq [related_object1, related_work2, related_object4, related_work5]
-        expect(subject.ordered_works).to eq [generic_work2, generic_work1]
-        expect(subject.ordered_file_sets).to eq [file_set1]
-      end
-    end
-  end
-
   describe 'should have parent work and collection accessors' do
     let(:collection1) { Hydra::Works::Collection.new }
     before do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hydra-works
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-30 00:00:00.000000000 Z
+date: 2015-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hydra-pcdm