active-fedora 6.8.0 → 7.0.0.pre1

data/spec/integration/belongs_to_association_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before do
+    class Library < ActiveFedora::Base 
+      has_many :books
+    end
+
+    class Book < ActiveFedora::Base 
+      belongs_to :library, :property=>:has_constituent
+    end
+    class SpecialInheritedBook < Book
+    end
+
+  end
+  after do
+    Object.send(:remove_const, :Library)
+    Object.send(:remove_const, :SpecialInheritedBook)
+    Object.send(:remove_const, :Book)
+  end
+
+  let(:library) { Library.create }
+  let(:book) { Book.new }
+
+  describe "setting the id property" do
+    it "should store it" do
+      book.library_id = library.id
+      book.library_id.should == library.id
+    end
+
+    describe "reassigning the parent_id" do
+      let(:library2) { Library.create}
+      before { book.library = library2 }
+      it "should update the object" do
+        expect(book.library).to eq library2 # cause the association to set @loaded
+        library_proxy = book.send(:association_instance_get, :library)
+        expect(library_proxy).to_not be_stale_target
+        book.library_id = library.id
+        expect(library_proxy).to be_stale_target
+        expect(book.library).to eq library
+      end
+    end
+
+    it "should be settable via []=" do
+      book[:library_id] = library.id
+      book.library_id.should == library.id
+    end
+  end
+
+  describe "getting the id property" do
+    it "should be accessable via []" do
+      book[:library_id] = library.id
+      book[:library_id].should == library.id
+    end
+  end
+
+  describe "when dealing with inherited objects" do
+    before do
+      @library2 = Library.create
+      @special_book = SpecialInheritedBook.create
+
+      book.library = @library2
+      book.save
+      @special_book.library = @library2
+      @special_book.save
+    end
+
+    it "should cast to the most specific class for the association" do
+      @library2.books[0].class == Book
+      @library2.books[1].class == SpecialInheritedBook
+    end
+
+    after do
+      @library2.delete
+      @special_book.delete
+    end
+  end
+
+  describe "casting inheritance additional test cases" do
+    before :all do
+      class SimpleObject < ActiveFedora::Base
+        belongs_to :simple_collection, property: :is_part_of, class_name: 'SimpleCollection'
+        belongs_to :complex_collection, property: :is_part_of, class_name: 'ComplexCollection'
+      end
+
+      class ComplexObject < SimpleObject
+      end
+
+      class SimpleCollection < ActiveFedora::Base
+        has_many :objects, property: :is_part_of, class_name: 'SimpleObject'
+        has_many :complex_objects, property: :is_part_of, class_name: 'ComplexObject'
+      end
+
+      class ComplexCollection < SimpleCollection
+      end
+
+    end
+    after :all do
+      Object.send(:remove_const, :SimpleObject)
+      Object.send(:remove_const, :ComplexObject)
+      Object.send(:remove_const, :SimpleCollection)
+      Object.send(:remove_const, :ComplexCollection)
+    end
+
+    describe "saving between the before and after hooks" do
+      before do
+        @simple_collection = SimpleCollection.create
+        @complex_collection = ComplexCollection.create
+
+        @simple_object = SimpleObject.create
+        @simple_object_second = SimpleObject.create
+        @complex_object = ComplexObject.create
+
+        #Need to add the simpler cmodel here as currently inheritance support is read-only.
+        #See ActiveFedora pull request 207 on how to do this programmatically.
+        @complex_object.add_relationship(:has_model, @complex_object.class.superclass.to_class_uri)
+
+        @simple_collection.objects = [@simple_object, @simple_object_second, @complex_object]
+        @simple_collection.save!
+        @complex_collection.objects = [@simple_object, @complex_object]
+        @complex_collection.save!
+        @complex_object.save!
+        @simple_object.save!
+        @simple_object_second.save!
+      end
+
+
+      it "casted association methods should work and return the most complex class" do
+        @complex_object.simple_collection.should be_instance_of SimpleCollection
+        @complex_object.complex_collection.should be_instance_of ComplexCollection
+
+        @simple_object.simple_collection.should be_instance_of SimpleCollection
+        @simple_object.complex_collection.should be_instance_of ComplexCollection
+        @simple_object_second.simple_collection.should be_instance_of SimpleCollection
+        @simple_object_second.complex_collection.should be_nil
+
+        @complex_collection.objects[0].should be_instance_of SimpleObject
+        @complex_collection.objects[1].should be_instance_of ComplexObject
+
+        @simple_collection.objects[0].should be_instance_of SimpleObject
+        @simple_collection.objects[1].should be_instance_of SimpleObject
+        @simple_collection.objects[2].should be_instance_of ComplexObject
+
+      end
+
+      it "specified ending relationships should ignore classes not specified" do
+        @complex_collection.complex_objects.count.should == 1
+        @complex_collection.complex_objects[0].should be_instance_of ComplexObject
+        @complex_collection.complex_objects[1].should be_nil
+
+        @simple_collection.complex_objects.count.should == 1
+        @simple_collection.complex_objects[0].should be_instance_of ComplexObject
+        @simple_collection.complex_objects[1].should be_nil
+
+      end
+
+      after do
+        @simple_object.delete
+        @simple_object_second.delete
+        @complex_object.delete
+      end
+    end
+  end
+end
+
+

data/spec/integration/bug_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 require 'active_fedora'
 require 'active_fedora/model'
-require 'rexml/document'
+require "rexml/document"
 include ActiveFedora::Model
 
 describe 'bugs' do
   before do
     class FooHistory < ActiveFedora::Base
-      has_metadata :type => ActiveFedora::SimpleDatastream, :name => 'someData' do |m|
-        m.field 'fubar', :string
+      has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
+        m.field "fubar", :string
       end
     end
     @test_object = FooHistory.new
@@ -26,17 +26,17 @@ describe 'bugs' do
     }.to raise_error(ActiveFedora::ObjectNotFoundError)
   end
 
-  it 'should not clobber everything when setting a value' do
-    @test_object.someData.fubar = ['initial']
+  it "should not clobber everything when setting a value" do
+    @test_object.someData.fubar=['initial']
     @test_object.save!
 
     x = FooHistory.find(@test_object.pid)
-    x.someData.fubar = ['replacement'] # set a new value
+    x.someData.fubar = ["replacement"] # set a new value
     x.save!
 
 
     x = FooHistory.find(@test_object.pid)
-    expect(x.someData.fubar).to eq(['replacement']) # recall the value
+    x.someData.fubar.should == ["replacement"] # recall the value
     x.save
   end
 end

data/spec/integration/collection_association_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe ActiveFedora::Base do
+  before do
+    class Library < ActiveFedora::Base 
+      has_many :books
+    end
+    class Book < ActiveFedora::Base
+      belongs_to :library, property: :has_member
+    end
+  end
+  let(:library) { Library.create! }
+  let!(:book1) { Book.create!(library: library) }
+  let!(:book2) { Book.create!(library: library) }
+  after do
+    Book.delete_all
+    Library.delete_all
+    Object.send(:remove_const, :Library)
+    Object.send(:remove_const, :Book)
+  end
+  describe "load_from_solr" do
+    it "should set rows to count, if not specified" do
+      library.books(response_format: :solr).size.should == 2
+    end
+    it "should limit rows returned if option passed" do
+      library.books(response_format: :solr, rows: 1).size.should == 1
+    end
+  end
+
+  describe "#delete_all" do
+    it "should delete em" do
+      expect {
+        library.books.delete_all
+      }.to change { library.books.count }.by(-2)
+    end
+  end
+
+  describe "#destroy_all" do
+    it "should delete em" do
+      expect {
+        library.books.destroy_all
+      }.to change { library.books.count }.by(-2)
+    end
+  end
+
+  describe "#find" do
+    it "should find the record that matches" do
+      expected = library.books.find(book1.id)
+      expect(expected).to eq book1
+    end
+    describe "with some records that aren't part of the collection" do
+      let!(:book3) { Book.create }
+      it "should find no records" do
+        expect(library.books.find(book3.id)).to be_nil
+      end
+    end
+  end
+end

data/spec/integration/complex_rdf_datastream_spec.rb

@@ -1,258 +1,258 @@
 require 'spec_helper'
 
-describe 'Nested Rdf Objects' do
-  describe 'without type' do
-    before(:each) do
+describe "Nested Rdf Objects" do
+  describe "without type" do
+    before(:each) do 
       class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
         map_predicates do |map|
-          map.parts(:in => RDF::DC, :to => 'hasPart', :class_name => 'Component')
+          map.parts(:in=> RDF::DC, :to=>'hasPart', :class_name=>'Component')
         end
 
         class Component
           include ActiveFedora::RdfObject
           map_predicates do |map|
-            map.label(:in => RDF::DC, :to => 'title')
+            map.label(:in=> RDF::DC, :to=>'title')
           end
         end
       end
 
     end
-
+    
     after(:each) do
       Object.send(:remove_const, :SpecDatastream)
     end
 
     let (:ds) do
-      mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
+      mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
       ds = SpecDatastream.new(mock_obj)
     end
 
-    describe '#new_record?' do
-      it 'should be true when its built' do
+    describe "#new_record?" do
+      it "should be true when its built" do
         v = ds.parts.build(label: 'Alternator')
-        expect(v).to be_new_record
+        v.should be_new_record
       end
 
       it "should not be new when it's loaded from fedora" do
         ds.content = '_:g70324142325120 <http://purl.org/dc/terms/title> "Alternator" .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70324142325120 .'
-        expect(ds.parts.first).not_to be_new_record
+        ds.parts.first.should_not be_new_record
       end
     end
 
-    it 'should not choke on invalid data' do
+    it "should not choke on invalid data" do
       # set a string in the graph where model expects a node
-      ds.parts = ['foo']
+      ds.parts = ["foo"]
       expect {ds.parts.inspect}.to raise_error(ArgumentError, "Expected the value of http://purl.org/dc/terms/hasPart to be an RDF object but it is a String \"foo\"")
     end
-
-    it 'should be able to nest a complex object' do
+    
+    it "should be able to nest a complex object" do
       comp = SpecDatastream::Component.new(ds.graph)
-      comp.label = ['Alternator']
+      comp.label = ["Alternator"]
       ds.parts = comp
-      expect(ds.parts.first.label).to eq(['Alternator'])
+      ds.parts.first.label.should == ["Alternator"]
     end
 
-    it 'should be able to replace attributes' do
+    it "should be able to replace attributes" do
       v = ds.parts.build(label: 'Alternator')
-      expect(ds.parts.first.label).to eq(['Alternator'])
+      ds.parts.first.label.should == ['Alternator']
       ds.parts.first.label = ['Distributor']
-      expect(ds.parts.first.label).to eq(['Distributor'])
+      ds.parts.first.label.should == ['Distributor']
     end
 
-    it 'should be able to replace objects' do
+    it "should be able to replace objects" do
       ds.parts.build(label: 'Alternator')
       ds.parts.build(label: 'Distributor')
-      expect(ds.parts.size).to eq(2)
+      ds.parts.size.should == 2
       comp = SpecDatastream::Component.new(ds.graph)
-      comp.label = 'Injector port'
+      comp.label = "Injector port"
       ds.parts = [comp]
-      expect(ds.parts.size).to eq(1)
+      ds.parts.size.should == 1
     end
 
-    it 'should be able to nest many complex objects' do
+    it "should be able to nest many complex objects" do
       comp1 = SpecDatastream::Component.new ds.graph
-      comp1.label = ['Alternator']
+      comp1.label = ["Alternator"]
       comp2 = SpecDatastream::Component.new ds.graph
-      comp2.label = ['Crankshaft']
+      comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
-      expect(ds.parts.first.label).to eq(['Alternator'])
-      expect(ds.parts.last.label).to eq(['Crankshaft'])
+      ds.parts.first.label.should == ["Alternator"]
+      ds.parts.last.label.should == ["Crankshaft"]
     end
 
-    it 'should be able to clear complex objects' do
+    it "should be able to clear complex objects" do
       comp1 = SpecDatastream::Component.new ds.graph
-      comp1.label = ['Alternator']
+      comp1.label = ["Alternator"]
       comp2 = SpecDatastream::Component.new ds.graph
-      comp2.label = ['Crankshaft']
+      comp2.label = ["Crankshaft"]
       ds.parts = [comp1, comp2]
       ds.parts = []
-      expect(ds.parts).to eq([])
+      ds.parts.should == []
     end
 
-    it 'should load complex objects' do
+    it "should load complex objects" do
       ds.content = <<END
 _:g70350851837440 <http://purl.org/dc/terms/title> "Alternator" .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851837440 .
 <info:fedora/test:124> <http://purl.org/dc/terms/hasPart> _:g70350851833380 .
 _:g70350851833380 <http://purl.org/dc/terms/title> "Crankshaft" .
 END
-      expect(ds.parts.first.label).to eq(['Alternator'])
+      ds.parts.first.label.should == ["Alternator"]
     end
 
     it "should build complex objects when a parent node doesn't exist" do
       part = ds.parts.build
-      expect(part).to be_kind_of SpecDatastream::Component
-      part.label = 'Wheel bearing'
-      expect(ds.parts.first.label).to eq(['Wheel bearing'])
+      part.should be_kind_of SpecDatastream::Component
+      part.label = "Wheel bearing"
+      ds.parts.first.label.should == ['Wheel bearing']
     end
 
-    it 'should not create a child node when hitting the accessor' do
+    it "should not create a child node when hitting the accessor" do
       ds.parts
-      expect(ds.parts.first).to be_nil
-      expect(ds.serialize).to eq('')
+      ds.parts.first.should be_nil
+      ds.serialize.should == ''
     end
 
-    it 'should build complex objects when a parent node exists' do
+    it "should build complex objects when a parent node exists" do
       part = ds.parts.build
-      expect(part).to be_kind_of SpecDatastream::Component
-      part.label = 'Wheel bearing'
-      expect(ds.parts.first.label).to eq(['Wheel bearing'])
+      part.should be_kind_of SpecDatastream::Component
+      part.label = "Wheel bearing"
+      ds.parts.first.label.should == ['Wheel bearing']
     end
 
-    describe '#first_or_create' do
-      it 'should return a result if the predicate exists' do
+    describe "#first_or_create" do
+      it "should return a result if the predicate exists" do
         part1 = ds.parts.build
         part2 = ds.parts.build
-        expect(ds.parts.first_or_create).to eq(part1)
+        ds.parts.first_or_create.should == part1
       end
 
       it "should create a new result if the predicate doesn't exist" do
-        expect(ds.parts).to eq([])
+        ds.parts.should == []
         part = ds.parts.first_or_create(label: 'Front control arm bushing')
-        expect(part.label).to eq(['Front control arm bushing'])
-        expect(ds.parts).to eq([part])
+        part.label.should == ['Front control arm bushing']
+        ds.parts.should == [part]
       end
 
     end
   end
 
 
-  describe 'with type' do
-    describe 'one class per assertion' do
-      before(:each) do
+  describe "with type" do
+    describe "one class per assertion" do 
+      before(:each) do 
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.mediator(:in => RDF::DC, :class_name => 'MediatorUser')
+            map.mediator(:in=> RDF::DC, :class_name=>'MediatorUser')
           end
 
           class MediatorUser
             include ActiveFedora::RdfObject
             rdf_type RDF::DC.AgentClass
             map_predicates do |map|
-              map.title(:in => RDF::DC)
+              map.title(:in=> RDF::DC)
             end
           end
         end
       end
-
+      
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
 
       let (:ds) do
-        mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
+        mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
         ds = SpecDatastream.new(mock_obj)
       end
 
 
-      it 'should store the type of complex objects when type is specified' do
+      it "should store the type of complex objects when type is specified" do
         comp = SpecDatastream::MediatorUser.new ds.graph
-        comp.title = ['Doctor']
+        comp.title = ["Doctor"]
         ds.mediator = comp
-        expect(ds.mediator.first.type.first).to be_instance_of RDF::Vocabulary::Term
-        expect(ds.mediator.first.type.first.to_s).to eq('http://purl.org/dc/terms/AgentClass')
-        expect(ds.mediator.first.title.first).to eq('Doctor')
+        ds.mediator.first.type.first.should be_instance_of RDF::URI
+        ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
+        ds.mediator.first.title.first.should == 'Doctor'
       end
 
-      it 'should add the type of complex object when it is not provided' do
+      it "should add the type of complex object when it is not provided" do
         ds.content = <<END
   _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Person" .
   <info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
 END
-        expect(ds.mediator.first.type.first.to_s).to eq('http://purl.org/dc/terms/AgentClass')
+        ds.mediator.first.type.first.to_s.should == "http://purl.org/dc/terms/AgentClass"
       end
 
-      it 'should add load the type of complex objects when provided (superceeding what is specified by the class)' do
+      it "should add load the type of complex objects when provided (superceeding what is specified by the class)" do
         ds.content = <<END
   _:g70350851837440 <http://purl.org/dc/terms/title> "Mediation Orgainzation" .
   _:g70350851837440 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.ebu.ch/metadata/ontologies/ebucore#Organisation> .
   <info:fedora/test:124> <http://purl.org/dc/terms/mediator> _:g70350851837440 .
 END
-        expect(ds.mediator.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Organisation')
+        ds.mediator.first.type.first.to_s.should == "http://www.ebu.ch/metadata/ontologies/ebucore#Organisation"
       end
     end
 
-    describe 'shared assertion to different classes' do
-      before(:each) do
-        class EbuCore < RDF::Vocabulary('http://www.ebu.ch/metadata/ontologies/ebucore#')
+    describe "shared assertion to different classes" do
+      before(:each) do 
+        class EbuCore < RDF::Vocabulary("http://www.ebu.ch/metadata/ontologies/ebucore#")
           property :isEpisodeOf
           property :title
         end
-
+        
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
           map_predicates do |map|
-            map.series(:to => 'isEpisodeOf', :in => EbuCore, :class_name => 'Series')
-            map.program(:to => 'isEpisodeOf', :in => EbuCore, :class_name => 'Program')
+            map.series(:to => 'isEpisodeOf', :in=> EbuCore, :class_name=>'Series')
+            map.program(:to => 'isEpisodeOf', :in=> EbuCore, :class_name=>'Program')
           end
 
           class Series
             include ActiveFedora::RdfObject
             rdf_type 'http://www.ebu.ch/metadata/ontologies/ebucore#Series'
             map_predicates do |map|
-              map.title(:in => EbuCore)
+              map.title(:in=> EbuCore)
             end
           end
 
-          class Program
+          class Program 
             include ActiveFedora::RdfObject
             rdf_type 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme'
             map_predicates do |map|
-              map.title(:in => EbuCore)
+              map.title(:in=> EbuCore)
             end
           end
         end
 
       end
-
+      
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
 
       let (:ds) do
-        mock_obj = double(:mock_obj, :pid => 'test:124', :new_record? => true)
+        mock_obj = double(:mock_obj, :pid=>'test:124', :new_record? => true)
         ds = SpecDatastream.new(mock_obj)
       end
 
 
-      it 'should store the type of complex objects when type is specified' do
+      it "should store the type of complex objects when type is specified" do
         series = SpecDatastream::Series.new ds.graph
-        series.title = ['renovating bathrooms']
+        series.title = ["renovating bathrooms"]
         ds.series = series
 
         program = SpecDatastream::Program.new ds.graph
-        program.title = ['This old House']
+        program.title = ["This old House"]
         ds.program = program
 
-        expect(ds.program.first.type.size).to eq(1)
-        expect(ds.program.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Programme')
-        expect(ds.series.first.type.size).to eq(1)
-        expect(ds.series.first.type.first.to_s).to eq('http://www.ebu.ch/metadata/ontologies/ebucore#Series')
+        ds.program.first.type.size.should == 1
+        ds.program.first.type.first.to_s.should == 'http://www.ebu.ch/metadata/ontologies/ebucore#Programme' 
+        ds.series.first.type.size.should == 1
+        ds.series.first.type.first.to_s.should == 'http://www.ebu.ch/metadata/ontologies/ebucore#Series' 
       end
 
-      it 'should create an object of the correct type' do
-        expect(ds.program.build).to be_kind_of SpecDatastream::Program
-        expect(ds.series.build).to be_kind_of SpecDatastream::Series
+      it "should create an object of the correct type" do
+        ds.program.build.should be_kind_of SpecDatastream::Program
+        ds.series.build.should be_kind_of SpecDatastream::Series
       end
     end
   end