hydra-pcdm 0.1.0 → 0.2.0

data/spec/hydra/pcdm/models/file_spec.rb

@@ -1,20 +1,19 @@
 require 'spec_helper'
 
 describe Hydra::PCDM::File do
+  let(:file) { described_class.new }
+  let(:reloaded) { described_class.new(file.uri) }
 
-  let(:file) { Hydra::PCDM::File.new }
-  let(:reloaded) { Hydra::PCDM::File.new(file.uri) }
-
-  describe "when saving" do
-    it "sets an RDF type" do
+  describe 'when saving' do
+    it 'sets an RDF type' do
       file.content = 'stuff'
       expect(file.save).to be true
-      expect(reloaded.metadata_node.query(predicate: RDF.type, object: RDFVocabularies::PCDMTerms.File).map(&:object)).to eq [RDFVocabularies::PCDMTerms.File]
+      expect(reloaded.metadata_node.query(predicate: RDF.type, object: Hydra::PCDM::Vocab::PCDMTerms.File).map(&:object)).to eq [Hydra::PCDM::Vocab::PCDMTerms.File]
     end
   end
 
-  describe "#label" do
-    it "saves a label" do
+  describe '#label' do
+    it 'saves a label' do
       file.content = 'stuff'
       file.label = 'foo'
       expect(file.label).to eq ['foo']
@@ -23,50 +22,51 @@ describe Hydra::PCDM::File do
     end
   end
 
-  describe "technical metadata" do
-    let(:date_created) { Date.parse "Fri, 08 May 2015 08:00:00 -0400 (EDT)" }
-    let(:date_modified) { Date.parse "Sat, 09 May 2015 09:00:00 -0400 (EDT)" }
-    let(:content) { "hello world" }
-    let(:file) { Hydra::PCDM::File.new.tap { |ds| ds.content = content } }
-    it "saves technical metadata" do
-      file.file_name = "picture.jpg"
-      file.file_size = content.length.to_s
-      file.date_created = date_created
-      file.has_mime_type = "application/jpg"
-      file.date_modified = date_modified
-      file.byte_order = "little-endian"
-      expect(file.save).to be true
-      expect(reloaded.file_name).to eq ["picture.jpg"]
-      expect(reloaded.file_size).to eq [content.length.to_s]
-      expect(reloaded.has_mime_type).to eq ["application/jpg"]
-      expect(reloaded.date_created).to eq [date_created]
-      expect(reloaded.date_modified).to eq [date_modified]
-      expect(reloaded.byte_order).to eq ["little-endian"]
+  describe 'technical metadata' do
+    let(:date_created) { Date.parse 'Fri, 08 May 2015 08:00:00 -0400 (EDT)' }
+    let(:date_modified) { Date.parse 'Sat, 09 May 2015 09:00:00 -0400 (EDT)' }
+    let(:content) { 'hello world' }
+    let(:file) { described_class.new.tap { |ds| ds.content = content } }
+    it 'saves technical metadata' do
+      skip('pending resolution of PCDM 182') do
+        file.file_name = 'picture.jpg'
+        file.file_size = content.length.to_s
+        file.date_created = date_created
+        file.has_mime_type = 'application/jpg'
+        file.date_modified = date_modified
+        file.byte_order = 'little-endian'
+        expect(file.save).to be true
+        expect(reloaded.file_name).to eq ['picture.jpg']
+        expect(reloaded.file_size).to eq [content.length.to_s]
+        expect(reloaded.has_mime_type).to eq ['application/jpg']
+        expect(reloaded.date_created).to eq [date_created]
+        expect(reloaded.date_modified).to eq [date_modified]
+        expect(reloaded.byte_order).to eq ['little-endian']
+      end
     end
 
-    it "does not save server managed properties" do
-      # Currently we can't write this property because Fedora 
-      # complains that it's a server managed property. This test 
+    it 'does not save server managed properties' do
+      # Currently we can't write this property because Fedora
+      # complains that it's a server managed property. This test
       # is mostly to document this situation.
-      file.file_hash = "the-hash"
-      expect{file.save}.to raise_error(Ldp::BadRequest)
+      file.file_hash = 'the-hash'
+      expect { file.save }.to raise_error(Ldp::Conflict, %r{Could not remove triple containing predicate http://www.loc.gov/premis/rdf/v1#hasMessageDigest to node .*})
     end
   end
 
-  describe "with a file that has no type" do
+  describe 'with a file that has no type' do
     subject { file.metadata_node.get_values(:type) }
-    let(:pcdm_file)   { RDFVocabularies::PCDMTerms.File }
-    let(:custom_type) { ::RDF::URI.new("http://example.com/MyType") }
+    let(:pcdm_file)   { Hydra::PCDM::Vocab::PCDMTerms.File }
+    let(:custom_type) { ::RDF::URI.new('http://example.com/MyType') }
 
-    it "should add a type that already exists" do
+    it 'add a type that already exists' do
       subject << pcdm_file
       expect(subject).to eq [pcdm_file]
     end
 
-    it "should add a custom type" do
+    it 'add a custom type' do
       subject << custom_type
       expect(subject).to include custom_type
     end
   end
-
 end

data/spec/hydra/pcdm/models/object_spec.rb

@@ -1,19 +1,18 @@
 require 'spec_helper'
 
 describe Hydra::PCDM::Object do
-
-  describe "#child_object_ids" do
+  describe '#object_ids' do
     let(:child1) { described_class.new(id: '1') }
     let(:child2) { described_class.new(id: '2') }
     let(:object) { described_class.new }
-    before { object.child_objects = [child1, child2] }
+    before { object.objects = [child1, child2] }
 
-    subject { object.child_object_ids }
+    subject { object.object_ids }
 
-    it { is_expected.to eq ["1", "2"] }
+    it { is_expected.to eq %w(1 2) }
   end
 
-  describe '#child_objects=, +=, <<' do
+  describe '#objects=, +=, <<' do
     context 'with acceptable child objects' do
       let(:object1) { described_class.new }
       let(:object2) { described_class.new }
@@ -21,28 +20,28 @@ describe Hydra::PCDM::Object do
       let(:object4) { described_class.new }
       let(:object5) { described_class.new }
 
-      it 'should be empty when no objects have been added' do
-        expect( subject.child_objects ).to eq []
+      it 'empty when no objects have been added' do
+        expect(subject.objects).to eq []
       end
 
-      it 'should add objects' do
-        subject.child_objects = [object1,object2]
-        subject.child_objects << object3
-        subject.child_objects += [object4,object5]
-        expect( subject.child_objects ).to eq [object1,object2,object3,object4,object5]
+      it 'add objects' do
+        subject.objects = [object1, object2]
+        subject.objects << object3
+        subject.objects += [object4, object5]
+        expect(subject.objects).to eq [object1, object2, object3, object4, object5]
       end
 
-      it 'should allow sub-objects' do
-        subject.child_objects = [object1,object2]
-        object1.child_objects = [object3]
-        expect( subject.child_objects ).to eq [object1,object2]
-        expect( object1.child_objects ).to eq [object3]
+      it 'allow sub-objects' do
+        subject.objects = [object1, object2]
+        object1.objects = [object3]
+        expect(subject.objects).to eq [object1, object2]
+        expect(object1.objects).to eq [object3]
       end
 
-      it 'should allow repeating objects' do
-        subject.child_objects = [object1,object2]
-        subject.child_objects << object1
-        expect( subject.child_objects ).to eq [object1,object2,object1]
+      it 'allow repeating objects' do
+        subject.objects = [object1, object2]
+        subject.objects << object1
+        expect(subject.objects).to eq [object1, object2, object1]
       end
 
       describe 'adding objects that are ancestors' do
@@ -51,46 +50,46 @@ describe Hydra::PCDM::Object do
 
         context 'when the source object is the same' do
           it 'raises an error' do
-            expect { object1.child_objects = [object1] }.to raise_error(error_type, error_message)
-            expect { object1.child_objects += [object1] }.to raise_error(error_type, error_message)
-            expect { object1.child_objects << [object1] }.to raise_error(error_type, error_message)
+            expect { object1.objects = [object1] }.to raise_error(error_type, error_message)
+            expect { object1.objects += [object1] }.to raise_error(error_type, error_message)
+            expect { object1.objects << [object1] }.to raise_error(error_type, error_message)
           end
         end
 
         before do
-          object1.child_objects = [object2]
+          object1.objects = [object2]
         end
 
         it 'raises an error' do
-          expect { object2.child_objects += [object1] }.to raise_error(error_type, error_message)
-          expect { object2.child_objects << [object1] }.to raise_error(error_type, error_message)
-          expect { object2.child_objects = [object1] }.to raise_error(error_type, error_message)
+          expect { object2.objects += [object1] }.to raise_error(error_type, error_message)
+          expect { object2.objects << [object1] }.to raise_error(error_type, error_message)
+          expect { object2.objects = [object1] }.to raise_error(error_type, error_message)
         end
 
         context 'with more ancestors' do
           before do
-            object2.child_objects = [object3]
+            object2.objects = [object3]
           end
 
           it 'raises an error' do
-            expect { object3.child_objects << [object1] }.to raise_error(error_type, error_message)
-            expect { object3.child_objects = [object1] }.to raise_error(error_type, error_message)
-            expect { object3.child_objects += [object1] }.to raise_error(error_type, error_message)
+            expect { object3.objects << [object1] }.to raise_error(error_type, error_message)
+            expect { object3.objects = [object1] }.to raise_error(error_type, error_message)
+            expect { object3.objects += [object1] }.to raise_error(error_type, error_message)
           end
 
           context 'with a more complicated example' do
             before do
-              object3.child_objects = [object4,object5]
+              object3.objects = [object4, object5]
             end
 
             it 'raises errors' do
-              expect { object4.child_objects = [object1] }.to raise_error(error_type, error_message)
-              expect { object4.child_objects += [object1] }.to raise_error(error_type, error_message)
-              expect { object4.child_objects << [object1] }.to raise_error(error_type, error_message)
+              expect { object4.objects = [object1] }.to raise_error(error_type, error_message)
+              expect { object4.objects += [object1] }.to raise_error(error_type, error_message)
+              expect { object4.objects << [object1] }.to raise_error(error_type, error_message)
 
-              expect { object4.child_objects = [object2] }.to raise_error(error_type, error_message)
-              expect { object4.child_objects += [object2] }.to raise_error(error_type, error_message)
-              expect { object4.child_objects << [object2] }.to raise_error(error_type, error_message)
+              expect { object4.objects = [object2] }.to raise_error(error_type, error_message)
+              expect { object4.objects += [object2] }.to raise_error(error_type, error_message)
+              expect { object4.objects << [object2] }.to raise_error(error_type, error_message)
             end
           end
         end
@@ -100,9 +99,9 @@ describe Hydra::PCDM::Object do
     context 'with unacceptable child objects' do
       before(:all) do
         @collection101   = Hydra::PCDM::Collection.new
-        @object101       = Hydra::PCDM::Object.new
+        @object101       = described_class.new
         @file101         = Hydra::PCDM::File.new
-        @non_PCDM_object = "I'm not a PCDM object"
+        @non_pcdm_object = "I'm not a PCDM object"
         @af_base_object  = ActiveFedora::Base.new
       end
 
@@ -111,28 +110,28 @@ describe Hydra::PCDM::Object do
       let(:error_type2)    { NoMethodError }
       let(:error_message2) { /undefined method `pcdm_object\?' for .*/ }
 
-      it 'should NOT aggregate Hydra::PCDM::Collection in objects aggregation' do
-        expect { @object101.child_objects = [@collection101] }.to raise_error(error_type1,error_message1)
-        expect { @object101.child_objects += [@collection101] }.to raise_error(error_type1,error_message1)
-        expect { @object101.child_objects << @collection101 }.to raise_error(error_type1,error_message1)
+      it 'NOT aggregate Hydra::PCDM::Collection in objects aggregation' do
+        expect { @object101.objects = [@collection101] }.to raise_error(error_type1, error_message1)
+        expect { @object101.objects += [@collection101] }.to raise_error(error_type1, error_message1)
+        expect { @object101.objects << @collection101 }.to raise_error(error_type1, error_message1)
       end
 
-      it 'should NOT aggregate Hydra::PCDM::Files in objects aggregation' do
-        expect { @object101.child_objects += [@file1] }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects << @file1 }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects = [@file1] }.to raise_error(error_type2,error_message2)
+      it 'NOT aggregate Hydra::PCDM::Files in objects aggregation' do
+        expect { @object101.objects += [@file1] }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects << @file1 }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects = [@file1] }.to raise_error(error_type2, error_message2)
       end
 
-      it 'should NOT aggregate non-PCDM objects in objects aggregation' do
-        expect { @object101.child_objects << @non_PCDM_object }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects = [@non_PCDM_object] }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects += [@non_PCDM_object] }.to raise_error(error_type2,error_message2)
+      it 'NOT aggregate non-PCDM objects in objects aggregation' do
+        expect { @object101.objects << @non_pcdm_object }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects = [@non_pcdm_object] }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects += [@non_pcdm_object] }.to raise_error(error_type2, error_message2)
       end
 
-      it 'should NOT aggregate AF::Base objects in objects aggregation' do
-        expect { @object101.child_objects = [@af_base_object] }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects += [@af_base_object] }.to raise_error(error_type2,error_message2)
-        expect { @object101.child_objects << @af_base_object }.to raise_error(error_type2,error_message2)
+      it 'NOT aggregate AF::Base objects in objects aggregation' do
+        expect { @object101.objects = [@af_base_object] }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects += [@af_base_object] }.to raise_error(error_type2, error_message2)
+        expect { @object101.objects << @af_base_object }.to raise_error(error_type2, error_message2)
       end
     end
   end
@@ -145,23 +144,23 @@ describe Hydra::PCDM::Object do
       let(:object4) { described_class.new }
       let(:object5) { described_class.new }
 
-      it 'should add objects' do
-        subject.members = [object1,object2]
+      it 'add objects' do
+        subject.members = [object1, object2]
         subject.members << object3
-        subject.members += [object4,object5]
-        expect( subject.members ).to eq [object1,object2,object3,object4,object5]
+        subject.members += [object4, object5]
+        expect(subject.members).to eq [object1, object2, object3, object4, object5]
       end
 
-      it 'should allow sub-objects' do
-        subject.members = [object1,object2]
+      it 'allow sub-objects' do
+        subject.members = [object1, object2]
         object1.members = [object3]
-        expect( subject.members ).to eq [object1,object2]
-        expect( object1.members ).to eq [object3]
+        expect(subject.members).to eq [object1, object2]
+        expect(object1.members).to eq [object3]
       end
 
-      it 'should allow repeating objects' do
-        subject.members = [object1,object2,object1]
-        expect( subject.members ).to eq [object1,object2,object1]
+      it 'allow repeating objects' do
+        subject.members = [object1, object2, object1]
+        expect(subject.members).to eq [object1, object2, object1]
       end
 
       describe 'adding objects that are ancestors' do
@@ -199,7 +198,7 @@ describe Hydra::PCDM::Object do
 
           context 'with a more complicated example' do
             before do
-              object3.members = [object4,object5]
+              object3.members = [object4, object5]
             end
 
             it 'raises errors' do
@@ -219,9 +218,9 @@ describe Hydra::PCDM::Object do
     context 'with unacceptable child objects' do
       before(:all) do
         @collection101   = Hydra::PCDM::Collection.new
-        @object101       = Hydra::PCDM::Object.new
+        @object101       = described_class.new
         @file101         = Hydra::PCDM::File.new
-        @non_PCDM_object = "I'm not a PCDM object"
+        @non_pcdm_object = "I'm not a PCDM object"
         @af_base_object  = ActiveFedora::Base.new
       end
 
@@ -234,27 +233,27 @@ describe Hydra::PCDM::Object do
       let(:error_type3)    { ActiveFedora::AssociationTypeMismatch }
       let(:error_message3) { /ActiveFedora::Base\(#\d+\) expected, got String\(#[\d]+\)/ }
 
-      it 'should NOT aggregate Hydra::PCDM::Collection in members aggregation' do
-        expect { @object101.members = [@collection101] }.to raise_error(error_type1,error_message1)
-        expect { @object101.members += [@collection101] }.to raise_error(error_type1,error_message1)
-        expect { @object101.members << @collection101 }.to raise_error(error_type1,error_message1)
+      it 'NOT aggregate Hydra::PCDM::Collection in members aggregation' do
+        expect { @object101.members = [@collection101] }.to raise_error(error_type1, error_message1)
+        expect { @object101.members += [@collection101] }.to raise_error(error_type1, error_message1)
+        expect { @object101.members << @collection101 }.to raise_error(error_type1, error_message1)
       end
-      it 'should NOT aggregate Hydra::PCDM::Files in members aggregation' do
-        expect { @object101.members += [@file1] }.to raise_error(error_type2,error_message2)
-        expect { @object101.members << @file1 }.to raise_error(error_type2,error_message2)
-        expect { @object101.members = [@file1] }.to raise_error(error_type2,error_message2)
+      it 'NOT aggregate Hydra::PCDM::Files in members aggregation' do
+        expect { @object101.members += [@file1] }.to raise_error(error_type2, error_message2)
+        expect { @object101.members << @file1 }.to raise_error(error_type2, error_message2)
+        expect { @object101.members = [@file1] }.to raise_error(error_type2, error_message2)
       end
 
-      it 'should NOT aggregate non-PCDM objects in members aggregation' do
-        expect { @object101.members << @non_PCDM_object }.to raise_error(error_type3,error_message3)
-        expect { @object101.members = [@non_PCDM_object] }.to raise_error(error_type3,error_message3)
-        expect { @object101.members += [@non_PCDM_object] }.to raise_error(error_type3,error_message3)
+      it 'NOT aggregate non-PCDM objects in members aggregation' do
+        expect { @object101.members << @non_pcdm_object }.to raise_error(error_type3, error_message3)
+        expect { @object101.members = [@non_pcdm_object] }.to raise_error(error_type3, error_message3)
+        expect { @object101.members += [@non_pcdm_object] }.to raise_error(error_type3, error_message3)
       end
 
-      it 'should NOT aggregate non-PCDM AF::Base objects in members aggregation' do
-        expect { @object101.members = [@af_base_object] }.to raise_error(error_type1,error_message1)
-        expect { @object101.members += [@af_base_object] }.to raise_error(error_type1,error_message1)
-        expect { @object101.members << @af_base_object }.to raise_error(error_type1,error_message1)
+      it 'NOT aggregate non-PCDM AF::Base objects in members aggregation' do
+        expect { @object101.members = [@af_base_object] }.to raise_error(error_type1, error_message1)
+        expect { @object101.members += [@af_base_object] }.to raise_error(error_type1, error_message1)
+        expect { @object101.members << @af_base_object }.to raise_error(error_type1, error_message1)
       end
     end
   end
@@ -265,12 +264,12 @@ describe Hydra::PCDM::Object do
       # All of the tests in this context are describing idempotent behavior, so isolation between examples isn't necessary.
       @collection1 = Hydra::PCDM::Collection.new
       @collection2 = Hydra::PCDM::Collection.new
-      @parent_object = Hydra::PCDM::Object.new
-      @object =  Hydra::PCDM::Object.new
+      @parent_object = described_class.new
+      @object = described_class.new
       @collection1.members = [@object]
       @collection2.members = [@object]
       @parent_object.members = [@object]
-      allow(@object).to receive(:id).and_return("banana")
+      allow(@object).to receive(:id).and_return('banana')
       proxies = [
         build_proxy(container: @collection1),
         build_proxy(container: @collection2),
@@ -279,22 +278,22 @@ describe Hydra::PCDM::Object do
       allow(ActiveFedora::Aggregation::Proxy).to receive(:where).with(proxyFor_ssim: @object.id).and_return(proxies)
     end
 
-    describe 'parents' do
-      subject { @object.parents }
-      it "finds all nodes that aggregate the object with hasMember" do
+    describe 'member_of' do
+      subject { @object.member_of }
+      it 'finds all nodes that aggregate the object with hasMember' do
         expect(subject).to include(@collection1, @collection2, @parent_object)
       end
     end
 
-    describe 'parent_objects' do
-      subject { @object.parent_objects }
-      it "finds objects that aggregate the object with hasMember" do
+    describe 'in_objects' do
+      subject { @object.in_objects }
+      it 'finds objects that aggregate the object with hasMember' do
         expect(subject).to eq [@parent_object]
       end
     end
-    describe 'parent_collections' do
-      subject { @object.parent_collections }
-      it "finds collections that aggregate the object with hasMember" do
+    describe 'in_collections' do
+      subject { @object.in_collections }
+      it 'finds collections that aggregate the object with hasMember' do
         expect(subject).to include(@collection1, @collection2)
         expect(subject.count).to eq 2
       end
@@ -306,102 +305,102 @@ describe Hydra::PCDM::Object do
 
   describe 'Related objects' do
     context 'with acceptable objects' do
-      let(:object1) { Hydra::PCDM::Object.new }
-      let(:object2) { Hydra::PCDM::Object.new }
-      let(:object3) { Hydra::PCDM::Object.new }
+      let(:object1) { described_class.new }
+      let(:object2) { described_class.new }
+      let(:object3) { described_class.new }
       let(:file1)   { Hydra::PCDM::File.new }
 
-      it 'should return empty array when no related object' do
-        expect( subject.related_objects ).to eq []
+      it 'return empty array when no related object' do
+        expect(subject.related_objects).to eq []
       end
 
-      it 'should add objects to the related object set' do
+      it 'add objects to the related object set' do
         subject.related_objects << object1      # first add
         subject.related_objects << object2      # second add to same object
         subject.save
         related_objects = subject.reload.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 'should not repeat objects in the related object set' do
-      skip 'pending resolution of ActiveFedora issue #853' do
-        subject.related_objects << object1      # first add
-        subject.related_objects << object2      # second add to same object
-        subject.related_objects << object1      # repeat an object replaces the object
-        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
+        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 'not repeat objects in the related object set' do
+        skip 'pending resolution of ActiveFedora issue #853' do
+          subject.related_objects << object1      # first add
+          subject.related_objects << object2      # second add to same object
+          subject.related_objects << object1      # repeat an object replaces the object
+          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 inputs' do
       before(:all) do
         @collection101   = Hydra::PCDM::Collection.new
-        @object101       = Hydra::PCDM::Object.new
+        @object101       = described_class.new
         @file101         = Hydra::PCDM::File.new
-        @non_PCDM_object = "I'm not a PCDM object"
+        @non_pcdm_object = "I'm not a PCDM object"
         @af_base_object  = ActiveFedora::Base.new
       end
       context 'with unacceptable related objects' do
         let(:error_message) { 'child_related_object must be a pcdm object' }
 
-        it 'should NOT aggregate Hydra::PCDM::Collection in objects aggregation' do
-          expect{ @object101.related_objects << @collection101 }.to raise_error(ActiveFedora::AssociationTypeMismatch,/Hydra::PCDM::Collection:.*> is not a PCDM object./)
+        it 'NOT aggregate Hydra::PCDM::Collection in objects aggregation' do
+          expect { @object101.related_objects << @collection101 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.*> is not a PCDM object./)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Files in objects aggregation' do
-          expect{ @object101.related_objects << @file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch,/ActiveFedora::Base.* expected, got NilClass.*/)
+        it 'NOT aggregate Hydra::PCDM::Files in objects aggregation' do
+          expect { @object101.related_objects << @file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got NilClass.*/)
         end
 
-        it 'should NOT aggregate non-PCDM objects in objects aggregation' do
-          expect{ @object101.related_objects << @non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch,/ActiveFedora::Base.* expected, got String.*/)
+        it 'NOT aggregate non-PCDM objects in objects aggregation' do
+          expect { @object101.related_objects << @non_pcdm_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
         end
 
-        it 'should NOT aggregate AF::Base objects in objects aggregation' do
-          expect{ @object101.related_objects << @af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch,/ActiveFedora::Base:.*> is not a PCDM object./)
+        it 'NOT aggregate AF::Base objects in objects aggregation' do
+          expect { @object101.related_objects << @af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base:.*> is not a PCDM object./)
         end
       end
 
       context 'with unacceptable parent object' do
-        it 'should NOT accept Hydra::PCDM::Files as parent object' do
-          expect{ @file1.related_objects << @object101 }.to raise_error(NoMethodError)
+        it 'NOT accept Hydra::PCDM::Files as parent object' do
+          expect { @file1.related_objects << @object101 }.to raise_error(NoMethodError)
         end
 
-        it 'should NOT accept non-PCDM objects as parent object' do
-          expect{ @non_PCDM_object.related_objects << @object101 }.to raise_error(NoMethodError)
+        it 'NOT accept non-PCDM objects as parent object' do
+          expect { @non_pcdm_object.related_objects << @object101 }.to raise_error(NoMethodError)
         end
 
-        it 'should NOT accept AF::Base objects as parent object' do
-          expect{ @af_base_object.related_objects << @object101 }.to raise_error(NoMethodError)
+        it 'NOT accept AF::Base objects as parent object' do
+          expect { @af_base_object.related_objects << @object101 }.to raise_error(NoMethodError)
         end
 
-        it 'should NOT accept Hydra::PCDM::Files as parent object' do
-          expect{ @file101.related_objects }.to raise_error(NoMethodError)
+        it 'NOT accept Hydra::PCDM::Files as parent object' do
+          expect { @file101.related_objects }.to raise_error(NoMethodError)
         end
 
-        it 'should NOT accept non-PCDM objects as parent object' do
-          expect{ @non_PCDM_object.related_objects }.to raise_error(NoMethodError)
+        it 'NOT accept non-PCDM objects as parent object' do
+          expect { @non_pcdm_object.related_objects }.to raise_error(NoMethodError)
         end
 
-        it 'should NOT accept AF::Base objects as parent object' do
-          expect{ @af_base_object.related_objects }.to raise_error(NoMethodError)
+        it 'NOT accept AF::Base objects as parent object' do
+          expect { @af_base_object.related_objects }.to raise_error(NoMethodError)
         end
       end
     end
   end
 
-  describe "removing related objects" do
-    subject { Hydra::PCDM::Object.new }
+  describe 'removing related objects' do
+    subject { described_class.new }
 
-    let(:object1) { Hydra::PCDM::Object.new }
-    let(:object2) { Hydra::PCDM::Object.new }
-    let(:object3) { Hydra::PCDM::Object.new }
-    let(:object4) { Hydra::PCDM::Object.new }
-    let(:object5) { Hydra::PCDM::Object.new }
+    let(:object1) { described_class.new }
+    let(:object2) { described_class.new }
+    let(:object3) { described_class.new }
+    let(:object4) { described_class.new }
+    let(:object5) { described_class.new }
 
     let(:file1) { Hydra::PCDM::File.new }
     let(:file2) { Hydra::PCDM::File.new }
@@ -409,12 +408,12 @@ describe Hydra::PCDM::Object do
     context 'when it is the only related object' do
       before do
         subject.related_objects << object1
-        expect( subject.related_objects ).to eq [object1]
+        expect(subject.related_objects).to eq [object1]
       end
 
-      it 'should remove related object while changes are in memory' do
-        expect( subject.related_objects.delete object1 ).to eq [object1]
-        expect( subject.related_objects ).to eq []
+      it 'remove related object while changes are in memory' do
+        expect(subject.related_objects.delete object1).to eq [object1]
+        expect(subject.related_objects).to eq []
       end
     end
 
@@ -425,218 +424,218 @@ describe Hydra::PCDM::Object do
         subject.related_objects << object3
         subject.related_objects << object4
         subject.related_objects << object5
-        expect( subject.related_objects ).to eq [object1,object2,object3,object4,object5]
+        expect(subject.related_objects).to eq [object1, object2, object3, object4, object5]
       end
 
-      it 'should remove first related object when changes are in memory' do
-        expect( subject.related_objects.delete object1 ).to eq [object1]
-        expect( subject.related_objects ).to eq [object2,object3,object4,object5]
+      it 'remove first related object when changes are in memory' do
+        expect(subject.related_objects.delete object1).to eq [object1]
+        expect(subject.related_objects).to eq [object2, object3, object4, object5]
       end
 
-      it 'should remove last related object when changes are in memory' do
-        expect( subject.related_objects.delete object5 ).to eq [object5]
-        expect( subject.related_objects ).to eq [object1,object2,object3,object4]
+      it 'remove last related object when changes are in memory' do
+        expect(subject.related_objects.delete object5).to eq [object5]
+        expect(subject.related_objects).to eq [object1, object2, object3, object4]
       end
 
-      it 'should remove middle related object when changes are in memory' do
-        expect( subject.related_objects.delete object3 ).to eq [object3]
-        expect( subject.related_objects ).to eq [object1,object2,object4,object5]
+      it 'remove middle related object when changes are in memory' do
+        expect(subject.related_objects.delete object3).to eq [object3]
+        expect(subject.related_objects).to eq [object1, object2, object4, object5]
       end
 
-      it 'should remove middle related object when changes are saved' do
-        expect( subject.related_objects ).to eq [object1,object2,object3,object4,object5]
-        expect( subject.related_objects.delete object3 ).to eq [object3]
+      it 'remove middle related object when changes are saved' do
+        expect(subject.related_objects).to eq [object1, object2, object3, object4, object5]
+        expect(subject.related_objects.delete object3).to eq [object3]
         subject.save
-        expect( subject.reload.related_objects ).to eq [object1,object2,object4,object5]
+        expect(subject.reload.related_objects).to eq [object1, object2, object4, object5]
       end
     end
 
     context 'when related object is missing' do
-      it 'should return empty array when 0 related objects and 0 objects' do
-        expect( subject.related_objects.delete object1 ).to eq []
+      it 'return empty array when 0 related objects and 0 objects' do
+        expect(subject.related_objects.delete object1).to eq []
       end
 
-      it 'should return empty array when other related objects and changes in memory' do
+      it 'return empty array when other related objects and changes in memory' do
         subject.related_objects << object1
         subject.related_objects << object2
         subject.related_objects << object4
         subject.related_objects << object5
-        expect( subject.related_objects.delete object3 ).to eq []
+        expect(subject.related_objects.delete object3).to eq []
       end
 
-      it 'should return empty array when other related objects and changes are in memory' do
+      it 'return empty array when other related objects and changes are in memory' do
         subject.related_objects << object1
         subject.related_objects << object2
         subject.related_objects << object4
         subject.related_objects << object5
-        expect( subject.related_objects.delete object3 ).to eq []
+        expect(subject.related_objects.delete object3).to eq []
       end
 
-      it 'should return empty array when changes are saved' do
+      it 'return empty array when changes are saved' do
         subject.related_objects << object1
         subject.related_objects << object2
         subject.related_objects << object4
         subject.related_objects << object5
         subject.save
-        expect( subject.reload.related_objects.delete object3 ).to eq []
+        expect(subject.reload.related_objects.delete object3).to eq []
       end
     end
   end
 
-  describe "removing child objects" do
-    subject { Hydra::PCDM::Object.new }
-    let(:object1) { Hydra::PCDM::Object.new }
-    let(:object2) { Hydra::PCDM::Object.new }
-    let(:object3) { Hydra::PCDM::Object.new }
+  describe 'removing child objects' do
+    subject { described_class.new }
+    let(:object1) { described_class.new }
+    let(:object2) { described_class.new }
+    let(:object3) { described_class.new }
 
     context 'when it is the only object' do
       before do
-        subject.child_objects += [object1]
-        expect( subject.child_objects ).to eq [object1]
+        subject.objects += [object1]
+        expect(subject.objects).to eq [object1]
       end
 
-      it 'should remove object while changes are in memory' do
-        expect( subject.child_objects.delete object1 ).to eq [object1]
-        expect( subject.child_objects ).to eq []
+      it 'remove object while changes are in memory' do
+        expect(subject.objects.delete object1).to eq [object1]
+        expect(subject.objects).to eq []
       end
     end
 
     context 'when multiple objects' do
       before do
-        subject.child_objects += [object1, object2, object3]
-        expect( subject.child_objects ).to eq [object1,object2,object3]
+        subject.objects += [object1, object2, object3]
+        expect(subject.objects).to eq [object1, object2, object3]
       end
 
-      it 'should remove first object when changes are in memory' do
-        expect( subject.child_objects.delete object1 ).to eq [object1]
-        expect( subject.child_objects ).to eq [object2,object3]
+      it 'remove first object when changes are in memory' do
+        expect(subject.objects.delete object1).to eq [object1]
+        expect(subject.objects).to eq [object2, object3]
       end
 
-      it 'should remove last object when changes are in memory' do
-        expect( subject.child_objects.delete object3 ).to eq [object3]
-        expect( subject.child_objects ).to eq [object1,object2]
+      it 'remove last object when changes are in memory' do
+        expect(subject.objects.delete object3).to eq [object3]
+        expect(subject.objects).to eq [object1, object2]
       end
 
-      it 'should remove middle object when changes are in memory' do
-        expect( subject.child_objects.delete object2 ).to eq [object2]
-        expect( subject.child_objects ).to eq [object1,object3]
+      it 'remove middle object when changes are in memory' do
+        expect(subject.objects.delete object2).to eq [object2]
+        expect(subject.objects).to eq [object1, object3]
       end
 
-      it 'should remove middle object when changes are saved' do
+      it 'remove middle object when changes are saved' do
         subject.save
-        expect( subject.child_objects ).to eq [object1,object2,object3]
-        expect( subject.child_objects.delete object2 ).to eq [object2]
-        expect( subject.child_objects ).to eq [object1,object3]
+        expect(subject.objects).to eq [object1, object2, object3]
+        expect(subject.objects.delete object2).to eq [object2]
+        expect(subject.objects).to eq [object1, object3]
       end
     end
     context 'when object repeats' do
       before do
-        subject.child_objects += [object1, object2, object3, object2, object3]
-        expect( subject.child_objects ).to eq [object1,object2,object3,object2,object3]
+        subject.objects += [object1, object2, object3, object2, object3]
+        expect(subject.objects).to eq [object1, object2, object3, object2, object3]
       end
 
-      it 'should remove first occurrence when changes in memory' do
-        expect( subject.child_objects.delete object2 ).to eq [object2]
-        expect( subject.child_objects ).to eq [object1,object3,object3]
+      it 'remove first occurrence when changes in memory' do
+        expect(subject.objects.delete object2).to eq [object2]
+        expect(subject.objects).to eq [object1, object3, object3]
       end
 
-      it 'should remove last occurrence when changes in memory' do
-      skip( "pending resolution of AF-agg 46 and PCDM 102") do
-        expect( subject.child_objects.delete object2, -1 ).to eq object2
-        expect( subject.child_objects ).to eq [object1,object2,object3,object3]
-      end
+      it 'remove last occurrence when changes in memory' do
+        skip('pending resolution of AF-agg 46 and PCDM 102') do
+          expect(subject.objects.delete object2, -1).to eq object2
+          expect(subject.objects).to eq [object1, object2, object3, object3]
+        end
       end
 
-      it 'should remove nth occurrence when changes in memory' do
-      skip( "pending resolution of AF-agg 46 and PCDM 102") do
-        expect( subject.child_objects.delete object2, 2 ).to eq object2
-        expect( subject.child_objects ).to eq [object1,object2,object3,object3]
-      end
+      it 'remove nth occurrence when changes in memory' do
+        skip('pending resolution of AF-agg 46 and PCDM 102') do
+          expect(subject.objects.delete object2, 2).to eq object2
+          expect(subject.objects).to eq [object1, object2, object3, object3]
+        end
       end
 
-      it 'should remove nth occurrence when changes are saved' do
-      skip( "pending resolution of AF-agg 46 and PCDM 102") do
-        expect( subject.child_objects ).to eq [object1,object2,object3,object2,object3]
-        expect( subject.child_objects ).to eq [object1,object2,object3,object2,object3]
+      it 'remove nth occurrence when changes are saved' do
+        skip('pending resolution of AF-agg 46 and PCDM 102') do
+          expect(subject.objects).to eq [object1, object2, object3, object2, object3]
+          expect(subject.objects).to eq [object1, object2, object3, object2, object3]
 
-        expect( subject.child_objects.delete object2, 2 ).to eq object2
-        subject.save
-        expect( subject.child_objects ).to eq [object1,object2,object3,object2,object3]
-      end
+          expect(subject.objects.delete object2, 2).to eq object2
+          subject.save
+          expect(subject.objects).to eq [object1, object2, object3, object2, object3]
+        end
       end
     end
 
     context 'when object is missing' do
-      it 'and 0 objects in object should return empty array' do
-        expect( subject.child_objects.delete object1 ).to eq []
+      it 'and 0 objects in object return empty array' do
+        expect(subject.objects.delete object1).to eq []
       end
 
-      it 'and multiple objects in object should return empty array when changes are in memory' do
-        subject.child_objects += [object1, object2]
-        expect( subject.child_objects.delete object3 ).to eq []
+      it 'and multiple objects in object return empty array when changes are in memory' do
+        subject.objects += [object1, object2]
+        expect(subject.objects.delete object3).to eq []
       end
 
-      it 'should return empty array when changes are saved' do
-        subject.child_objects += [object1, object2]
-        expect( subject.child_objects.delete object3 ).to eq []
+      it 'return empty array when changes are saved' do
+        subject.objects += [object1, object2]
+        expect(subject.objects.delete object3).to eq []
       end
     end
   end
 
   describe '#files' do
     subject { described_class.new }
-    it "should have a files relation" do
+    it 'have a files relation' do
       reflection = subject.reflections[:files]
       expect(reflection.macro).to eq :directly_contains
-      expect(reflection.options[:has_member_relation]).to eq RDFVocabularies::PCDMTerms.hasFile
-      expect(reflection.options[:class_name].to_s).to eq "Hydra::PCDM::File"
+      expect(reflection.options[:has_member_relation]).to eq Hydra::PCDM::Vocab::PCDMTerms.hasFile
+      expect(reflection.options[:class_name].to_s).to eq 'Hydra::PCDM::File'
     end
   end
 
-  describe "filtering files" do
+  describe 'filtering files' do
     let(:object) { described_class.create }
-    let(:thumbnail)   do
+    let(:thumbnail) do
       file = object.files.build
       Hydra::PCDM::AddTypeToFile.call(file, pcdm_thumbnail_uri)
     end
 
     let(:file)                { object.files.build }
-    let(:pcdm_thumbnail_uri)  { ::RDF::URI("http://pcdm.org/ThumbnailImage") }
+    let(:pcdm_thumbnail_uri)  { ::RDF::URI('http://pcdm.org/ThumbnailImage') }
 
     before do
       file
     end
 
-    describe "filter_files_by_type" do
-      context "when the object has files with that type" do
+    describe 'filter_files_by_type' do
+      context 'when the object has files with that type' do
         before do
           thumbnail
         end
-        it "allows you to filter the contained files by type URI" do
-          expect( object.filter_files_by_type(pcdm_thumbnail_uri) ).to eq [thumbnail]
+        it 'allows you to filter the contained files by type URI' do
+          expect(object.filter_files_by_type(pcdm_thumbnail_uri)).to eq [thumbnail]
         end
-        it "only overrides the #files method when you specify :type" do
-          expect( object.files ).to eq [file, thumbnail]
+        it 'only overrides the #files method when you specify :type' do
+          expect(object.files).to eq [file, thumbnail]
         end
       end
-      context "when the object does NOT have any files with that type" do
-        it "returns an empty array" do
-          expect( object.filter_files_by_type(pcdm_thumbnail_uri) ).to eq []
+      context 'when the object does NOT have any files with that type' do
+        it 'returns an empty array' do
+          expect(object.filter_files_by_type(pcdm_thumbnail_uri)).to eq []
         end
       end
     end
 
-    describe "file_of_type" do
-      context "when the object has files with that type" do
+    describe 'file_of_type' do
+      context 'when the object has files with that type' do
         before do
           thumbnail
         end
-        it "returns the first file with the requested type" do
-          expect( object.file_of_type(pcdm_thumbnail_uri) ).to eq thumbnail
+        it 'returns the first file with the requested type' do
+          expect(object.file_of_type(pcdm_thumbnail_uri)).to eq thumbnail
         end
       end
-      context "when the object does NOT have any files with that type" do
-        it "initializes a contained file with the requested type" do
+      context 'when the object does NOT have any files with that type' do
+        it 'initializes a contained file with the requested type' do
           returned_file =  object.file_of_type(pcdm_thumbnail_uri)
           expect(object.files).to include(returned_file)
           expect(returned_file).to be_new_record
@@ -646,12 +645,12 @@ describe Hydra::PCDM::Object do
     end
   end
 
-  describe ".indexer" do
+  describe '.indexer' do
     after do
       Object.send(:remove_const, :Foo)
     end
 
-    context "without overriding" do
+    context 'without overriding' do
       before do
         class Foo < ActiveFedora::Base
           include Hydra::PCDM::ObjectBehavior
@@ -662,7 +661,7 @@ describe Hydra::PCDM::Object do
       it { is_expected.to eq Hydra::PCDM::ObjectIndexer }
     end
 
-    context "when overridden with AS::Concern" do
+    context 'when overridden with AS::Concern' do
       before do
         module IndexingStuff
           extend ActiveSupport::Concern
@@ -687,4 +686,19 @@ describe Hydra::PCDM::Object do
     end
   end
 
+  describe 'make sure deprecated methods still work' do
+    let(:object1) { described_class.new }
+    let(:object2) { described_class.new }
+    let(:object3) { described_class.new }
+    let(:object4) { described_class.new }
+
+    it 'deprecated methods should pass' do
+      expect(object1.child_objects = [object2]).to eq [object2]
+      expect(object1.child_objects << object3).to eq [object2, object3]
+      expect(object1.child_objects += [object4]).to eq [object2, object3, object4]
+      object1.save # required until issue AF-Agg-75 is fixed
+      expect(object2.parent_objects).to eq [object1]
+      expect(object2.parents).to eq [object1]
+    end
+  end
 end