active-fedora 9.1.2 → 9.2.0.rc1

data/spec/integration/collection_association_spec.rb

@@ -76,20 +76,20 @@ describe ActiveFedora::Base do
       before do
         class Item < ActiveFedora::Base
         end
-        class Container < ActiveFedora::Base
+        class SpecContainer < ActiveFedora::Base
           has_many :items
         end
       end
       after do
         Object.send(:remove_const, :Item)
-        Object.send(:remove_const, :Container)
+        Object.send(:remove_const, :SpecContainer)
       end
 
-      let(:instance) { Container.new }
+      let(:instance) { SpecContainer.new }
       subject { instance.items }
 
       it "raises an error" do
-        expect { subject }.to raise_error "No :inverse_of or :predicate attribute was set or could be inferred for has_many :items on Container"
+        expect { subject }.to raise_error "No :inverse_of or :predicate attribute was set or could be inferred for has_many :items on SpecContainer"
       end
     end
 

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -36,7 +36,7 @@ describe "Nested Rdf Objects" do
     end
 
     it "should be able to nest a complex object" do
-      comp = SpecDatastream::Component.new(ds.graph)
+      comp = SpecDatastream::Component.new(nil, ds.graph)
       comp.label = ["Alternator"]
       ds.parts = comp
       expect(ds.parts.first.label).to eq ["Alternator"]
@@ -53,16 +53,16 @@ describe "Nested Rdf Objects" do
       ds.parts.build(label: 'Alternator')
       ds.parts.build(label: 'Distributor')
       expect(ds.parts.size).to eq 2
-      comp = SpecDatastream::Component.new(ds.graph)
+      comp = SpecDatastream::Component.new(nil, ds.graph)
       comp.label = "Injector port"
       ds.parts = [comp]
       expect(ds.parts.size).to eq 1
     end
 
     it "should be able to nest many complex objects" do
-      comp1 = SpecDatastream::Component.new ds.graph
+      comp1 = SpecDatastream::Component.new nil, ds.graph
       comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new ds.graph
+      comp2 = SpecDatastream::Component.new nil, ds.graph
       comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       expect(ds.parts.first.label).to eq ["Alternator"]
@@ -70,9 +70,9 @@ describe "Nested Rdf Objects" do
     end
 
     it "should be able to clear complex objects" do
-      comp1 = SpecDatastream::Component.new ds.graph
+      comp1 = SpecDatastream::Component.new nil, ds.graph
       comp1.label = ["Alternator"]
-      comp2 = SpecDatastream::Component.new ds.graph
+      comp2 = SpecDatastream::Component.new nil, ds.graph
       comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       ds.parts = []
@@ -147,7 +147,7 @@ END
 
 
       it "should store the type of complex objects when type is specified" do
-        comp = SpecDatastream::MediatorUser.new ds.graph
+        comp = SpecDatastream::MediatorUser.new nil, ds.graph
         comp.title = ["Doctor"]
         ds.mediator = comp
         expect(ds.mediator.first.type.first).to be_instance_of ::RDF::URI
@@ -180,7 +180,7 @@ END
           property :title
         end
 
-        class Container < ActiveFedora::Base
+        class SpecContainer < ActiveFedora::Base
           contains :info, class_name: 'SpecDatastream'
         end
 
@@ -203,19 +203,19 @@ END
 
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
-        Object.send(:remove_const, :Container)
+        Object.send(:remove_const, :SpecContainer)
       end
 
-      let(:parent) { Container.new id: '124' }
+      let(:parent) { SpecContainer.new id: '124' }
       let (:file) { parent.info }
 
 
       it "should store the type of complex objects when type is specified" do
-        series = SpecDatastream::Series.new file.graph
+        series = SpecDatastream::Series.new nil, file.graph
         series.title = ["renovating bathrooms"]
         file.series = series
 
-        program = SpecDatastream::Program.new file.graph
+        program = SpecDatastream::Program.new nil, file.graph
         program.title = ["This old House"]
         file.program = program
 

data/spec/integration/datastream_rdf_nested_attributes_spec.rb

@@ -99,7 +99,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       end
 
       describe "on lists" do
-        subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
+        subject { ComplexRDFDatastream::PersonalName.new(nil) }
         it "should accept a hash" do
           subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
           expect(subject.elementList.first[0].elementValue).to eq ["Quantum Behavior"]

data/spec/integration/direct_container_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe "Direct containers" do
+  describe "#directly_contains" do
+    context "when the class is ActiveFedora::File" do
+      before do
+        class FooHistory < ActiveFedora::Base
+           directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles")
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+
+      let(:file) { o.files.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      context "with no files" do
+        let(:o) { FooHistory.new }
+        subject { o.files }
+
+        it { is_expected.to be_empty }
+        it { is_expected.to eq [] }
+      end
+
+      context "when the object exists" do
+        let(:o) { FooHistory.create }
+
+        before do
+          file.content = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.files.first }
+          it "has the content" do
+            expect(subject.content).to eq 'HMMM'
+          end
+        end
+
+        describe "#to_a" do
+          subject { reloaded.files }
+          it "has the content" do
+            expect(subject.to_a).to eq [file]
+          end
+        end
+
+        describe "#append" do
+          let(:file2) { o.files.build }
+          it "has two files" do
+            expect(o.files).to eq [file, file2]
+          end
+
+          context "and then saved/reloaded" do
+            before do
+              file2.content = "Derp"
+              o.save!
+            end
+            it "has two files" do
+              expect(reloaded.files).to eq [file, file2]
+            end
+          end
+        end
+      end
+
+      context "when the object is new" do
+        let(:o) { FooHistory.new }
+        let(:file) { o.files.build }
+
+        it "fails" do
+          # This is the expected behavior right now. In the future make the uri get assigned by autosave.
+          expect { o.files.build }.to raise_error "Can't get uri. Owner isn't saved"
+        end
+      end
+    end
+
+    context "when the class is a subclass of ActiveFedora::File" do
+      before do
+        class SubFile < ActiveFedora::File; end
+        class FooHistory < ActiveFedora::Base
+           directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles"), class_name: 'SubFile'
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+        Object.send(:remove_const, :SubFile)
+      end
+
+      let(:o) { FooHistory.create }
+      let(:file) { o.files.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      describe "#build" do
+        subject { file }
+        it { is_expected.to be_kind_of SubFile }
+      end
+
+      context "when the object exists" do
+        before do
+          file.content = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.files.first }
+          it "has the content" do
+            expect(subject.content).to eq 'HMMM'
+          end
+        end
+      end
+    end
+
+    context "when using is_member_of_relation" do
+      before do
+        class FooHistory < ActiveFedora::Base
+           directly_contains :files, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin")
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+
+      let(:file) { o.files.build }
+      let(:reloaded) { FooHistory.find(o.id) }
+
+      context "with no files" do
+        let(:o) { FooHistory.new }
+        subject { o.files }
+
+        it { is_expected.to be_empty }
+        it { is_expected.to eq [] }
+      end
+
+      context "when the object exists" do
+        let(:o) { FooHistory.create }
+
+        before do
+          file.content = "HMMM"
+          o.save
+        end
+
+        describe "#first" do
+          subject { reloaded.files.first }
+          it "has the content" do
+            expect(subject.content).to eq 'HMMM'
+          end
+        end
+      end
+    end
+
+    context "deleting members" do
+      before do
+        class FooHistory < ActiveFedora::Base
+           directly_contains :files, is_member_of_relation: ::RDF::URI.new("http://example.com/isWithin")
+        end
+      end
+      after do
+        Object.send(:remove_const, :FooHistory)
+      end
+
+      describe "#delete the contained object directly" do
+        let(:history) { FooHistory.create }
+        let(:file1) { history.files.build }
+        let(:file2) { history.files.build }
+
+        before do
+          file1.content = "hello"
+          file2.content = "hola"
+          history.save
+          history.reload
+        end
+
+        it "deletes the contained resource directly" do
+          expect(history.files).to eq [file1, file2]
+          file1.delete
+          history.reload
+          expect(history.files).to eq [file2]
+        end
+      end
+
+      describe "#delete via the collection proxy" do
+        let(:history) { FooHistory.create }
+        let(:file1) { history.files.build }
+        let(:file2) { history.files.build }
+
+        before do
+          file1.content = "hello"
+          file2.content = "hola"
+          history.save
+          history.reload
+        end
+
+        it "deletes the contained resource via the collection proxy" do
+          expect(history.reload.files).to eq [file1, file2]
+          history.files.delete(file1)
+          expect(history.reload.files).to eq [file2]
+        end
+      end
+
+    end
+
+  end
+
+  describe "#include?" do
+
+    before do
+      class FooHistory < ActiveFedora::Base
+        directly_contains :files, has_member_relation: ::RDF::URI.new('http://example.com/hasFiles')
+      end
+    end
+
+    after do
+      Object.send(:remove_const, :FooHistory)
+    end
+
+    let(:foo) { FooHistory.create }
+
+    let!(:file1) { foo.files.build }
+
+    before do
+      file1.content = 'hmm'
+      foo.save
+    end
+
+    context "when it is not loaded" do
+      context "and it contains the file" do
+        subject { foo.reload.files.include? file1 }
+        it { is_expected.to be true }
+      end
+
+      context "and it doesn't contain the file" do
+        let!(:file2) { ActiveFedora::File.new.tap { |f| f.content= 'hmm'; f.save } }
+        subject { foo.reload.files.include? file2 }
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when it is loaded" do
+      before { foo.files.to_a } # initial load of the association
+
+      context "and it contains the file" do
+        subject { foo.files.include? file1 }
+        it { is_expected.to be true }
+      end
+
+      context "and it doesn't contain the file" do
+        let!(:file2) { ActiveFedora::File.new.tap { |f| f.content= 'hmm'; f.save } }
+        subject { foo.files.include? file2 }
+        it { is_expected.to be false }
+      end
+    end
+  end
+
+end

data/spec/integration/directly_contains_one_association_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before do
+    class PageImage < ActiveFedora::Base
+      directly_contains :files, has_member_relation: ::RDF::URI.new("http://example.com/hasFiles"), class_name:"FileWithMetadata"
+      directly_contains_one :primary_file, through: :files, type: ::RDF::URI.new("http://example.com/primaryFile"), class_name:"FileWithMetadata"
+      directly_contains_one :special_versioned_file, through: :files, type: ::RDF::URI.new("http://example.com/featuredFile"), class_name:'VersionedFileWithMetadata'
+    end
+
+    class FileWithMetadata < ActiveFedora::File
+      include ActiveFedora::WithMetadata
+    end
+    class VersionedFileWithMetadata < ActiveFedora::File
+      include ActiveFedora::WithMetadata
+      has_many_versions
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :PageImage)
+    Object.send(:remove_const, :FileWithMetadata)
+    Object.send(:remove_const, :VersionedFileWithMetadata)
+  end
+
+  let(:page_image)              { PageImage.create }
+  let(:reloaded_page_image)     { PageImage.find(page_image.id) }
+
+  let(:a_file)                  { page_image.files.build }
+  let(:primary_file)            { page_image.build_primary_file }
+  let(:special_versioned_file)  { page_image.build_special_versioned_file }
+  let(:primary_sub_image)       { page_image.build_primary_sub_image }
+
+
+  context "#build" do
+    context "when container element is a type of ActiveFedora::File" do
+      before do
+        primary_file.content = "I'm in a container all alone!"
+        page_image.save!
+      end
+      subject { reloaded_page_image.primary_file }
+      it "initializes an object within the container" do
+        expect(subject.content).to eq("I'm in a container all alone!")
+        expect(subject.metadata_node.type).to include( ::RDF::URI.new("http://example.com/primaryFile") )
+      end
+      it "relies on info from the :through association, including class_name" do
+        expect(page_image.files).to include(primary_file)
+        expect(primary_file.uri.to_s).to include("/files/")
+        expect(subject.class).to eq FileWithMetadata
+      end
+    end
+  end
+
+  context "finder" do
+    subject { reloaded_page_image.primary_file }
+    context "when no matching child is set" do
+      before { page_image.files.build}
+      it { is_expected.to be_nil }
+    end
+    context "when a matching object is directly contained" do
+      before do
+        a_file.content = "I'm a file"
+        primary_file.content = "I am too"
+        page_image.save!
+      end
+      it "returns the matching object" do
+        expect(subject).to eq primary_file
+      end
+    end
+    context "if class_name is set" do
+      before do
+        a_file.content = "I'm a file"
+        special_versioned_file.content = "I am too"
+        page_image.save!
+      end
+      subject { reloaded_page_image.special_versioned_file }
+      it "uses the specified class to load objects" do
+        expect(subject).to eq special_versioned_file
+        expect(subject).to be_instance_of VersionedFileWithMetadata
+      end
+    end
+  end
+
+  describe "setter" do
+    before do
+      a_file.content = "I'm a file"
+      primary_file.content = "I am too"
+      page_image.save!
+    end
+    subject { reloaded_page_image.files }
+    it "replaces existing record without disturbing the other contents of the container" do
+      replacement_file = page_image.primary_file = FileWithMetadata.new
+      replacement_file.content = "I'm a replacement"
+      page_image.save
+      expect(subject).to_not include(primary_file)
+      expect(subject).to eq([a_file, replacement_file])
+      expect(reloaded_page_image.primary_file).to eq(replacement_file)
+    end
+
+  end
+
+end