hydra-works 0.0.1 → 0.1.0

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

@@ -18,13 +18,42 @@ module Hydra::Works
 
     included do
       type [RDFVocabularies::PCDMTerms.Object,WorksVocabularies::WorksTerms.GenericWork]
-      include Hydra::Works::AggregatesGenericFiles
-      include Hydra::Works::AggregatesGenericWorks
+      include Hydra::Works::BlockChildObjects
+
+      filters_association :members, as: :child_generic_works, condition: :works_generic_work?
+      filters_association :members, as: :generic_files, condition: :works_generic_file?
     end
 
     def contains= files
       raise NoMethodError, "works can not directly contain files.  You must add a GenericFile to the work's members and add files to that GenericFile."
     end
 
+    # @return [Boolean] whether this instance is a Hydra::Works Collection.
+    def works_collection?
+      false
+    end
+
+    # @return [Boolean] whether this instance is a Hydra::Works Generic Work.
+    def works_generic_work?
+      true
+    end
+
+    # @return [Boolean] whether this instance is a Hydra::Works Generic File.
+    def works_generic_file?
+      false
+    end
+
+    def parents
+      aggregated_by
+    end
+
+    def parent_generic_works
+      aggregated_by.select { |parent| parent.class.included_modules.include?(Hydra::Works::GenericWorkBehavior) }
+    end
+
+    def parent_collections
+      aggregated_by.select { |parent| parent.class.included_modules.include?(Hydra::Works::CollectionBehavior) }
+    end
+
   end
-end
+end

data/lib/hydra/works/models/generic_file.rb

@@ -7,6 +7,9 @@ module Hydra::Works
     autoload :Derivatives,            'hydra/works/models/concerns/generic_file/derivatives'
     autoload :MimeTypes,              'hydra/works/models/concerns/generic_file/mime_types'
     autoload :ContainedFiles,         'hydra/works/models/concerns/generic_file/contained_files'
+    autoload :VersionedContent,       'hydra/works/models/concerns/generic_file/versioned_content'
+    autoload :VirusCheck,             'hydra/works/models/concerns/generic_file/virus_check'
+
 
     # Base class for creating objects that behave like Hydra::Works::GenericFiles
     class Base < ActiveFedora::Base

data/lib/hydra/works/services/generic_file/add_file_to_generic_file.rb

@@ -0,0 +1,127 @@
+module Hydra::Works
+  class AddFileToGenericFile
+
+    # Adds a file to the generic_file
+    # @param [Hydra::PCDM::GenericFile::Base] generic_file the file will be added to
+    # @param [IO,File,Rack::Multipart::UploadedFile, #read] object that will be the contents. If file responds to :mime_type, :content_type, :original_name, or :original_filename, those will be called to provide metadata.
+    # @param [RDF::URI or String] type URI for the RDF.type that identifies the file's role within the generic_file
+    # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within generic_file.files.
+    # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
+
+    def self.call(generic_file, file, type, update_existing: true, versioning: true)
+      raise ArgumentError, "supplied object must be a generic file" unless generic_file.works_generic_file?
+      raise ArgumentError, "supplied file must respond to read" unless file.respond_to? :read
+
+      # TODO required as a workaround for https://github.com/projecthydra/active_fedora/pull/858
+      generic_file.save unless generic_file.persisted?
+
+      updater_class = versioning ? VersioningUpdater : Updater
+      updater = updater_class.new(generic_file, type, update_existing)
+      status = updater.update(file)
+      status ? generic_file : false
+    end
+
+    class Updater
+      attr_reader :generic_file, :current_file
+
+      def initialize(generic_file, type, update_existing)
+        @generic_file = generic_file
+        @current_file = find_or_create_file(type, update_existing)
+      end
+
+      # @param [#read] file object that will be interrogated using the methods: :path, :original_name, :original_filename, :mime_type, :content_type
+      # None of the attribute description methods are required.
+      def update(file)
+        attach_attributes(file)
+        persist
+      end
+
+      private
+
+        def persist
+          if current_file.new_record?
+            # persist current_file and its membership in generic_file.files container
+            generic_file.save
+          else
+            # we updated the content of an existing file, so we need to save the file explicitly
+            current_file.save
+          end
+        end
+
+        def attach_attributes(file) 
+          current_file.content = file
+          current_file.original_name = determine_original_name(file)
+          current_file.mime_type = determine_mime_type(file)
+        end
+
+        # Return mime_type based on methods available to file
+        # @param object for mimetype to be determined. Attempts to use methods: :mime_type, :content_type, and :path.
+        def determine_mime_type(file)
+          if file.respond_to? :mime_type
+            return file.mime_type
+          elsif file.respond_to? :content_type
+            return file.content_type
+          elsif file.respond_to? :path
+            return Hydra::PCDM::GetMimeTypeForFile.call(file.path)
+          else
+            return "application/octet-stream"
+          end
+        end
+
+        # Return original_name based on methods available to file
+        # @param object for original name to be determined. Attempts to use methods: :original_name, :original_filename, and :path.
+        def determine_original_name(file)
+          if file.respond_to? :original_name
+            return file.original_name
+          elsif file.respond_to? :original_filename
+            return file.original_filename
+          elsif file.respond_to? :path
+            return ::File.basename(file.path)
+          else
+            return ""
+          end
+        end
+
+        # @param [Symbol, RDF::URI] the type of association or filter to use
+        # @param [true, false] update_existing when true, try to retrieve existing element before building one
+        def find_or_create_file(type, update_existing)
+          if type.instance_of? Symbol
+            association = generic_file.association(type)
+            raise ArgumentError, "you're attempting to add a file to a generic_file using '#{type}' association but the generic_file does not have an association called '#{type}''" unless association
+
+            current_file = association.reader if update_existing
+            current_file ||= association.build
+          else
+            current_file = generic_file.filter_files_by_type(type_to_uri(type)).first if update_existing
+            unless current_file
+              generic_file.files.build
+              current_file = generic_file.files.last
+              Hydra::PCDM::AddTypeToFile.call(current_file, type_to_uri(type))
+            end
+          end
+        end
+
+        # Returns appropriate URI for the requested type
+        #  * Converts supported symbols to corresponding URIs
+        #  * Converts URI strings to RDF::URI
+        #  * Returns RDF::URI objects as-is
+        def type_to_uri(type)
+          case type
+          when ::RDF::URI
+            type
+          when String
+            ::RDF::URI(type)
+          else
+            raise ArgumentError, "Invalid file type.  You must submit a URI or a symbol."
+          end
+        end
+      end  
+
+      class VersioningUpdater < Updater
+        def update(*)
+          super && current_file.create_version
+        end
+      end
+  end
+end
+

data/lib/hydra/works/services/generic_file/generate/thumbnail.rb

@@ -7,8 +7,7 @@ module Hydra::Works
 
       # Always replace the thumbnail with whatever is from the original file
       if object.thumbnail.nil?
-        object.files.build
-        AddTypeToFile.call(object.files.last, ::RDF::URI("http://pcdm.org/ThumbnailImage"))
+        object.build_thumbnail
       end
       
       object.create_derivatives

data/lib/hydra/works/services/generic_file/persist_derivative.rb

@@ -0,0 +1,22 @@
+require 'hydra/derivatives'
+
+module Hydra::Works
+  class PersistDerivative < Hydra::Derivatives::PersistOutputFileService
+
+    ##
+    # Persists a derivative to a GenericFile
+    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.  
+    # The purpose of this Service is for use as an alternative to the default Hydra::Derivatives::PersistOutputFileService.  It's necessary because the default behavior in Hydra::Derivatives assumes that you're using LDP Basic Containment. Hydra::Works::GenericFiles use IndirectContainment.  This Service handles that case.
+    # This service will always update existing and does not do versioning of persisted files.
+    # 
+    # @param [Hydra::Works::GenericFile::Base] object the file will be added to
+    # @param [#read or String] file the derivative filestream optionally responds to :mime_type
+    # @param [String] extract file type symbol (e.g. :thumbnail) from Hydra::Derivatives created destination_name
+
+    def self.call(object, file, destination_name)
+      type = destination_name.gsub(/^original_file_/, '').to_sym
+      Hydra::Works::AddFileToGenericFile.call(object, file, type, update_existing: true, versioning: false)
+    end
+
+  end
+end

data/lib/hydra/works/services/generic_file/upload_file.rb

@@ -1,31 +1,23 @@
 module Hydra::Works
   class UploadFileToGenericFile
 
-    def self.call(object, path, additional_services=[], replace=false)
-      raise ArgumentError, "supplied object must be a generic file" unless Hydra::Works.generic_file?(object)
-      raise ArgumentError, "supplied path must be a string" unless path.is_a?(String)
-      raise ArgumentError, "supplied path to file does not exist" unless ::File.exists?(path)
-    
-      if object.original_file.nil? || object.original_file.new_record?
-        Hydra::Works::AddOriginalFile.call(object, path)
-      else
-        if replace
-          Hydra::Works::AddOriginalFile.call(object, path, replace)
-        else
-          Hydra::Works::AddVersionedOriginalFile.call(object, path)
-        end
-      end
+    # Sets a file as the primary file (original_file) of the generic_file
+    # @param [Hydra::PCDM::GenericFile::Base] generic_file the file will be added to
+    # @param [IO,File,Rack::Multipart::UploadedFile, #read] object that will be the contents. If file responds to :mime_type or :original_name, those will be called to provide technical metadata.
+    # @param [Array] additional_services (ie Generating Thumbnails) to call with generic_file after adding the file as its original_file
+    # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within generic_file.files.
+    # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
 
-      object.save
-      object.reload
+  def self.call(generic_file, file, additional_services: [], update_existing: true, versioning: true)
+      Hydra::Works::AddFileToGenericFile.call(generic_file, file, :original_file, update_existing: update_existing, versioning: versioning)
 
       # Call any additional services
       additional_services.each do |service|
-        service.call(object)
+        service.call(generic_file)
       end
 
-      object.save
-      object
+      generic_file.save
+      generic_file
     end
 
   end

data/lib/hydra/works/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module Works
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/lib/hydra/works/vocab/works_terms.rb

@@ -1,6 +1,6 @@
 require 'rdf'
 module WorksVocabularies
-  class WorksTerms < RDF::Vocabulary("http://hydra.org/works/models#")
+  class WorksTerms < RDF::Vocabulary("http://projecthydra.org/works/models#")
 
     # Class definitions
     term :Collection

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

@@ -2,40 +2,523 @@ require 'spec_helper'
 
 describe Hydra::Works::Collection do
 
-  let(:collection1) { Hydra::Works::Collection.create }
-  let(:collection2) { Hydra::Works::Collection.create }
-  let(:collection3) { Hydra::Works::Collection.create }
+  subject { Hydra::Works::Collection.new }
 
-  let(:generic_work1) { Hydra::Works::GenericWork::Base.create }
-  let(:generic_work2) { Hydra::Works::GenericWork::Base.create }
+  let(:collection1) { Hydra::Works::Collection.new }
+  let(:collection2) { Hydra::Works::Collection.new }
+  let(:collection3) { Hydra::Works::Collection.new }
+
+  let(:generic_work1) { Hydra::Works::GenericWork::Base.new }
+  let(:generic_work2) { Hydra::Works::GenericWork::Base.new }
+  let(:generic_work3) { Hydra::Works::GenericWork::Base.new }
+
+  describe '#child_collections' do
+    it 'should return empty array when only generic_works are aggregated' do
+      subject.child_generic_works << generic_work1
+      subject.child_generic_works << generic_work2
+      expect(subject.child_collections ).to eq []
+    end
+
+    context 'with other collections & generic_works' do 
+      before do 
+        subject.child_collections << collection1
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work1
+        subject.child_generic_works << generic_work2
+      end
+
+      it 'should only return collections' do
+        expect(subject.child_collections ).to eq [collection1,collection2]
+      end
+    end  
+  end
+
+  describe '#child_collections <<' do
+    context 'with acceptable collections' do
+      context 'with collections and generic_works' do
+        before do
+          subject.child_collections << collection1
+          subject.child_collections << collection2
+          subject.child_generic_works << generic_work1
+          subject.child_generic_works << generic_work2
+        end
+
+        it 'should add an generic_work to collection with collections and generic_works' do
+          subject.child_collections << collection3
+          expect( subject.child_collections ).to eq [collection1,collection2,collection3]
+        end
+      end
+
+      describe 'aggregates collections that implement Hydra::Works' do
+        before do
+          class Kollection < ActiveFedora::Base
+            include Hydra::Works::CollectionBehavior
+          end
+        end
+        after { Object.send(:remove_const, :Kollection) }
+        let(:kollection1) { Kollection.new }
+
+        it 'should accept implementing collection as a child' do
+          subject.child_collections << kollection1
+          expect( subject.child_collections ).to eq [kollection1]
+        end
+
+        it 'should accept implementing collection as a parent' do
+          subject.child_collections << collection1
+          expect( subject.child_collections ).to eq [collection1]
+        end
+      end
+
+      describe 'aggregates collections that extend Hydra::Works' do
+        before do
+          class Cullection < Hydra::Works::Collection
+          end
+        end
+        after { Object.send(:remove_const, :Cullection) }
+        let(:cullection1) { Cullection.new }
+
+        it 'should accept extending collection as a child' do
+          subject.child_collections << cullection1
+          expect( subject.child_collections ).to eq [cullection1]
+        end
+
+        it 'should accept extending collection as a parent' do
+          subject.child_collections << collection1
+          expect( subject.child_collections ).to eq [collection1]
+        end
+      end
+    end
+
+    context 'with unacceptable inputs' do
+      before(:all) do
+        @works_collection101  = Hydra::Works::Collection.new
+        @generic_work101      = Hydra::Works::GenericWork::Base.new
+        @generic_file101      = Hydra::Works::GenericFile::Base.new
+        @pcdm_collection101   = Hydra::PCDM::Collection.new
+        @pcdm_object101       = Hydra::PCDM::Object.new
+        @pcdm_file101         = Hydra::PCDM::File.new
+        @non_PCDM_object      = "I'm not a PCDM object"
+        @af_base_object       = ActiveFedora::Base.new
+      end
+
+      context 'that are unacceptable child collections' do
+
+        let(:error_type1)    { ArgumentError }
+        let(:error_message1) { /Hydra::Works::Generic(Work|File)::Base with ID:  was expected to works_collection\?, but it was false/ }
+        let(:error_type2)    { NoMethodError }
+        let(:error_message2) { /undefined method `works_collection\?' for .*/ }
+
+        it 'should NOT aggregate Hydra::Works::GenericWork in collections aggregation' do
+          expect{ subject.child_collections << @generic_work101 }.to raise_error(error_type1,error_message1)
+        end
+
+        it 'should NOT aggregate Hydra::Works::GenericFile in collections aggregation' do
+          expect{ subject.child_collections << @generic_file101 }.to raise_error(error_type1,error_message1)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Collections in collections aggregation' do
+          expect{ subject.child_collections << @pcdm_collection101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Objects in collections aggregation' do
+          expect{ subject.child_collections << @pcdm_object101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Files in collections aggregation' do
+          expect{ subject.child_collections << @pcdm_file101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate non-PCDM objects in collections aggregation' do
+          expect{ subject.child_collections << @non_PCDM_object }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate AF::Base objects in collections aggregation' do
+          expect{ subject.child_collections << @af_base_object }.to raise_error(error_type2,error_message2)
+        end
+      end
+    end
+  end
+
+  describe 'child_collections.delete' do
+    context 'when multiple collections' do
+      before do
+        subject.child_collections << collection1
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work2
+        subject.child_collections << collection3
+        subject.child_generic_works << generic_work1
+        expect( subject.child_collections ).to eq [collection1,collection2,collection3]
+      end
+      
+      it 'should remove first collection' do
+        expect( subject.child_collections.delete collection1 ).to eq [collection1]
+        expect( subject.child_collections ).to eq [collection2,collection3]
+        expect( subject.child_generic_works ).to eq [generic_work2,generic_work1]    
+      end
+        
+      it 'should remove last collection' do
+        expect( subject.child_collections.delete collection3 ).to eq [collection3]
+        expect( subject.child_collections ).to eq [collection1,collection2]
+        expect( subject.child_generic_works). to eq [generic_work2,generic_work1]      
+      end
+   
+      it 'should remove middle collection' do
+        expect( subject.child_collections.delete collection2 ).to eq [collection2]
+        expect( subject.child_collections ).to eq [collection1,collection3]
+        expect( subject.child_generic_works). to eq [generic_work2,generic_work1]    
+      end
+    end 
+  end   
+
+  describe '#child_generic_works' do
+    it 'should return empty array when only collections are aggregated' do
+      subject.child_collections << collection1
+      subject.child_collections << collection2
+      expect(subject.child_generic_works). to eq []
+    end
+
+    context 'with collections and generic works' do
+      before do 
+        subject.child_collections << collection1
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work1
+        subject.child_generic_works << generic_work2
+      end
+
+      it 'should only return generic works' do
+        expect(subject.child_generic_works). to eq [generic_work1,generic_work2]     
+      end
+    end
+  end 
+
+  describe '#child_generic_works <<' do
+    
+    context 'with acceptable generic_works' do
+      context 'with collections and generic_works' do
+        before do
+          subject.child_collections << collection1
+          subject.child_collections << collection2
+          subject.child_generic_works << generic_work1
+          subject.child_generic_works << generic_work2
+        end
+
+        it 'should add generic_work to collection with collections and generic_works' do 
+          subject.child_generic_works << generic_work3
+          expect( subject.child_generic_works  ).to eq [generic_work1,generic_work2,generic_work3]
+        end
+      end
+      
+      describe 'aggregates generic_works that implement Hydra::Works' do
+        before do
+          class DummyIncWork < ActiveFedora::Base
+            include Hydra::Works::GenericWorkBehavior
+          end
+        end
+        after { Object.send(:remove_const, :DummyIncWork) }
+        let(:iwork1) { DummyIncWork.new }
+        
+        it 'should accept implementing generic_work as a child' do
+          subject.child_generic_works << iwork1
+          expect( subject.child_generic_works  ).to eq [iwork1]
+        end
+      end 
+
+      describe 'aggregates generic_works that extend Hydra::Works' do
+        before do
+          class DummyExtWork < Hydra::Works::GenericWork::Base
+          end
+        end
+        after { Object.send(:remove_const, :DummyExtWork) }
+        let(:ework1) { DummyExtWork.new }
+
+        it 'should accept extending generic_work as a child' do
+          subject.child_generic_works << ework1
+          expect( subject.child_generic_works  ).to eq [ework1]
+        end
+      end
+    end
+
+    context 'with unacceptable inputs' do
+      before(:all) do
+        @works_collection101  = Hydra::Works::Collection.new
+        @works_collection102  = Hydra::Works::Collection.new
+        @generic_file101      = Hydra::Works::GenericFile::Base.new
+        @pcdm_collection101   = Hydra::PCDM::Collection.new
+        @pcdm_object101       = Hydra::PCDM::Object.new
+        @pcdm_file101         = Hydra::PCDM::File.new
+        @non_PCDM_object      = "I'm not a PCDM object"
+        @af_base_object       = ActiveFedora::Base.new
+      end
+
+      context 'that are unacceptable child generic works' do
+
+        let(:error_type1)    { ArgumentError }
+        let(:error_message1) { /Hydra::Works::(GenericFile::Base|Collection) with ID:  was expected to works_generic_work\?, but it was false/ }
+        let(:error_type2)    { NoMethodError }
+        let(:error_message2) { /undefined method `works_generic_work\?' for .*/ }
+
+        it 'should NOT aggregate Hydra::Works::Collection in generic works aggregation' do
+          expect{ subject.child_generic_works << @works_collection101 }.to raise_error(error_type1,error_message1)
+        end
+
+        it 'should NOT aggregate Hydra::Works::GenericFile in generic works aggregation' do
+          expect{ subject.child_generic_works << @generic_file101 }.to raise_error(error_type1,error_message1)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Collections in generic works aggregation' do
+          expect{ subject.child_generic_works << @pcdm_collection101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Objects in generic works aggregation' do
+          expect{ subject.child_generic_works << @pcdm_object101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate Hydra::PCDM::Files in generic works aggregation' do
+          expect{ subject.child_generic_works << @pcdm_file101 }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate non-PCDM objects in generic works aggregation' do
+          expect{ subject.child_generic_works << @non_PCDM_object }.to raise_error(error_type2,error_message2)
+        end
+
+        it 'should NOT aggregate AF::Base objects in generic works aggregation' do
+          expect{ subject.child_generic_works << @af_base_object }.to raise_error(error_type2,error_message2)
+        end
+      end
+    end
+  end
+
+  describe '#child_generic_works.delete' do
+    context 'when multiple generic works' do
+      before do
+        subject.child_generic_works << generic_work1
+        subject.child_generic_works << generic_work2
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work3
+        subject.child_collections << collection1
+        expect( subject.child_generic_works). to eq [generic_work1,generic_work2,generic_work3]
+      end
+      
+      it 'should remove first generic work' do
+        expect( subject.child_generic_works.delete generic_work1 ).to eq [generic_work1]
+        expect( subject.child_generic_works). to eq [generic_work2,generic_work3]
+        expect( subject.child_collections ).to eq [collection2,collection1]
+      end
+        
+      it 'should remove last generic work' do
+        expect( subject.child_generic_works.delete generic_work3 ).to eq [generic_work3]
+        expect( subject.child_generic_works). to eq [generic_work1,generic_work2]
+        expect( subject.child_collections ).to eq [collection2,collection1]
+      end
+   
+      it 'should remove middle generic work' do
+        expect( subject.child_generic_works.delete generic_work2 ).to eq [generic_work2]
+        expect( subject.child_generic_works). to eq [generic_work1,generic_work3]
+        expect( subject.child_collections ).to eq [collection2,collection1]
+      end
+    end 
+  end   
+
+  describe '#related_objects' do
+    let(:generic_file1) { Hydra::Works::GenericFile::Base.new }
+    let(:object1) { Hydra::PCDM::Object.new }
+    let(:object2) { Hydra::PCDM::Object.new }
+
+    context 'with collections and generic works' do
+      before do
+        subject.child_collections << collection1
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work1
+      end
+        
+      it 'should return empty array when only collections and generic works are aggregated' do
+        expect(subject.related_objects ).to eq []
+      end
+      
+      it 'should only return related objects' do
+        subject.related_objects << object2
+        expect(subject.related_objects ).to eq [object2]
+      end
+  
+      it 'should return 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::GenericFile::Base.new }
+
+      it 'should add 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 generic_works' do
+        before do
+          subject.child_collections << collection1
+          subject.child_collections << collection2
+          subject.child_generic_works << generic_work1
+          subject.child_generic_works << generic_work2
+          subject.related_objects << object1
+        end
+
+        it 'should add a related object to collection with collections and generic_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 'should 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 'should 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 'should 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 'should 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 'should 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 'should 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
+      end
+    end
+  end
+
+  describe '#related_objects.delete' do
+    let(:related_object1) { Hydra::PCDM::Object.new }
+    let(:related_work2)   { Hydra::Works::GenericWork::Base.new }
+    let(:related_file3)   { Hydra::Works::GenericFile::Base.new }
+    let(:related_object4) { Hydra::PCDM::Object.new }
+    let(:related_work5)   { Hydra::Works::GenericWork::Base.new }
+
+    context 'when multiple related objects' do
+      before do
+        subject.related_objects << related_object1
+        subject.related_objects << related_work2
+        subject.child_collections << collection2
+        subject.child_generic_works << generic_work1
+        subject.related_objects << related_file3
+        subject.related_objects << related_object4
+        subject.child_collections << collection1
+        subject.related_objects << related_work5
+        expect( subject.related_objects ).to eq [related_object1,related_work2,related_file3,related_object4,related_work5]
+      end
+        
+      it 'should remove 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.child_collections ).to eq [collection2,collection1]
+        expect( subject.child_generic_works). to eq [generic_work1]
+      end
+
+      it 'should remove 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.child_collections ).to eq [collection2,collection1]
+        expect( subject.child_generic_works). to eq [generic_work1]
+      end
+        
+      it 'should remove 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.child_collections ).to eq [collection2,collection1]
+        expect( subject.child_generic_works). to eq [generic_work1]
+      end
+    end 
+  end   
 
   describe '#collections=' do
     it 'should aggregate collections' do
-      collection1.collections = [collection2, collection3]
-      collection1.save
-      expect(collection1.collections).to eq [collection2, collection3]
+      collection1.child_collections = [collection2, collection3]
+      expect(collection1.child_collections).to eq [collection2, collection3]
     end
   end
 
-  describe '#generic_works=' do
+  describe '#child_generic_works=' do
     it 'should aggregate generic_works' do
-      collection1.generic_works = [generic_work1,generic_work2]
-      collection1.save
-      expect(collection1.generic_works).to eq [generic_work1,generic_work2]
+      collection1.child_generic_works = [generic_work1,generic_work2]
+      expect(collection1.child_generic_works).to eq [generic_work1,generic_work2]
     end
   end
 
   describe 'Related objects' do
-    let(:object) { Hydra::PCDM::Object.create }
-    let(:collection) { Hydra::Works::Collection.create }
+    let(:object) { Hydra::PCDM::Object.new }
+    let(:collection) { Hydra::Works::Collection.new }
 
     before do
       collection.related_objects = [object]
-      collection.save
     end
 
     it 'persists' do
-      expect(collection.reload.related_objects).to eq [object]
+      expect(collection.related_objects).to eq [object]
+    end
+  end
+
+  describe "should have parent collection accessors" do
+    before do
+      collection1.child_collections << collection2
+      collection1.save
+    end
+
+    it 'should have parents' do
+      expect(collection2.parents).to eq [collection1]
+    end
+    it 'should have a parent collection' do
+      expect(collection2.parent_collections).to eq [collection1]
     end
   end
 end