active-fedora 3.1.0.pre2 → 3.1.0.pre3

data/spec/unit/base_spec.rb

@@ -203,19 +203,16 @@ describe ActiveFedora::Base do
 
   describe '#add_relationship' do
     it 'should call #add_relationship on the rels_ext datastream' do
-      mock_relationship = mock("relationship")
-      mock_rels_ext = mock("rels-ext", :add_relationship)
+      mock_rels_ext = mock("rels-ext")#, :add_relationship)
       mock_rels_ext.expects(:dirty=).with(true)
       @test_object.expects(:relationship_exists?).returns(false).once()
-      @test_object.expects(:rels_ext).returns(mock_rels_ext).times(2) 
+      @test_object.expects(:rels_ext).returns(mock_rels_ext) 
       @test_object.add_relationship("predicate", "object")
     end
 
     it "should update the RELS-EXT datastream and set the datastream as dirty when relationships are added" do
       mock_ds = mock("Rels-Ext")
-      mock_ds.expects(:add_relationship).times(2)
       mock_ds.expects(:dirty=).with(true).times(2)
-      @test_object.expects(:relationship_exists?).returns(false).times(2)
       @test_object.datastreams["RELS-EXT"] = mock_ds
       test_relationships = [ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:5"), 
         ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/demo:10")]
@@ -229,15 +226,15 @@ describe ActiveFedora::Base do
       @test_object3 = ActiveFedora::Base.new
       @test_object.add_relationship(:has_part,@test_object3)
       r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
-      @test_object.relationships.should == {:self=>{:has_part=>[r.object]}}
+      @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid]
       #try adding again and make sure not there twice
       @test_object.add_relationship(:has_part,@test_object3)
-      @test_object.relationships.should == {:self=>{:has_part=>[r.object]}}
+      @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid]
     end
 
     it 'should add literal relationships if requested' do
       @test_object.add_relationship(:conforms_to,"AnInterface",true)
-      @test_object.relationships[:self][:conforms_to].should == ["AnInterface"]
+      @test_object.ids_for_outbound(:conforms_to).should == ["AnInterface"]
     end
   end
   
@@ -253,16 +250,14 @@ describe ActiveFedora::Base do
       @test_object4 = ActiveFedora::Base.new
       @test_object.add_relationship(:has_part,@test_object3)
       @test_object.add_relationship(:has_part,@test_object4)
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object3)
-      r2 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object4)
       #check both are there
-      @test_object.relationships.should == {:self=>{:has_part=>[r.object,r2.object]}}
+      @test_object.ids_for_outbound(:has_part).should == [@test_object3.pid,@test_object4.pid]
       @test_object.remove_relationship(:has_part,@test_object3)
       #check only one item removed
-      @test_object.relationships.should == {:self=>{:has_part=>[r2.object]}}
+      @test_object.ids_for_outbound(:has_part).should == [@test_object4.pid]
       @test_object.remove_relationship(:has_part,@test_object4)
       #check last item removed and predicate removed since now emtpy
-      @test_object.relationships.should == {:self=>{}}
+      @test_object.relationships.size.should == 0
     end
   end
 
@@ -271,9 +266,9 @@ describe ActiveFedora::Base do
   end
 
   describe '#relationships' do
-    it 'should call #relationships on the rels_ext datastream and return that' do
-      @test_object.expects(:rels_ext).returns(mock("rels-ext", :relationships))
-      @test_object.relationships
+    it 'should return a graph' do
+      @test_object.relationships.kind_of?(RDF::Graph).should be_true
+      @test_object.relationships.size.should == 0 
     end
   end
 
@@ -384,6 +379,7 @@ describe ActiveFedora::Base do
       dirty_ds = ActiveFedora::MetadataDatastream.new(@test_object.inner_object, 'ds1')
       rels_ds = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
       rels_ds.expects(:new?).returns(false)
+      rels_ds.model = @test_object
       mock2 = mock("ds2")
       mock2.stubs(:changed? => false)
       mock2.expects(:serialize!)
@@ -405,6 +401,7 @@ describe ActiveFedora::Base do
       mock_rels_ext.stubs(:dsid=>"RELS-EXT", :relationships=>{}, :add_relationship=>nil, :dirty= => nil)
       mock_rels_ext.expects( :changed?).returns(false).at_least_once
       mock_rels_ext.expects(:serialize!)
+      mock_rels_ext.expects(:model=).with(@test_object)
       ActiveFedora::RelsExtDatastream.expects(:new).returns(mock_rels_ext)
       @test_object.stubs(:datastreams).returns({:ds1 => mock1, :ds2 => mock2})
       @test_object.expects(:update_index).never
@@ -415,16 +412,16 @@ describe ActiveFedora::Base do
        
       @test_object.save
     end
-    it "should update solr index if RELS-EXT datastream has changed" do
+    it "should update solr index if relationships have changed" do
       @mock_repo = mock('repository')
       @mock_repo.expects(:ingest).with(:pid => @test_object.pid)
       @test_object.inner_object.expects(:repository).returns(@mock_repo).at_least_once
       @test_object.inner_object.expects(:new?).returns(true).twice
 
       rels_ext = ActiveFedora::RelsExtDatastream.new(@test_object.inner_object, 'RELS-EXT')
-      rels_ext.expects(:relationships_are_dirty).returns(true).at_least_once
+      rels_ext.model = @test_object
       rels_ext.expects(:new?).returns(true)
-      rels_ext.expects(:save).returns(true)
+       rels_ext.expects(:save).returns(true)
       rels_ext.expects(:serialize!)
       clean_ds = mock("ds2")
       clean_ds.stubs(:dirty? => false, :changed? => false, :new? => false)

data/spec/unit/content_model_spec.rb

@@ -55,16 +55,16 @@ describe ActiveFedora::ContentModel do
   
   describe "#pid_from_ruby_class" do
     it "should construct pids" do
-     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == "afmodel:ActiveFedora_ContentModel"
-     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class, :namespace => "foo", :pid_suffix => "BarBar").should == "foo:ActiveFedora_ContentModelBarBar"
+     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == "info:fedora/afmodel:ActiveFedora_ContentModel"
+     ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class, :namespace => "foo", :pid_suffix => "BarBar").should == "info:fedora/foo:ActiveFedora_ContentModelBarBar"
     end
     it "should construct pids with the namespace declared in the model" do
       ActiveFedora::ContentModel.stubs(:pid_namespace).returns("test-cModel")
-      ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == "test-cModel:ActiveFedora_ContentModel"
+      ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == "info:fedora/test-cModel:ActiveFedora_ContentModel"
     end
     it "should construct pids with the suffix declared in the model" do
       ActiveFedora::ContentModel.stubs(:pid_suffix).returns("-TEST-SUFFIX")
-      ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == 'afmodel:ActiveFedora_ContentModel-TEST-SUFFIX'
+      ActiveFedora::ContentModel.pid_from_ruby_class(@test_cmodel.class).should == 'info:fedora/afmodel:ActiveFedora_ContentModel-TEST-SUFFIX'
     end
   end
   

data/spec/unit/relationships_helper_spec.rb

@@ -6,6 +6,7 @@ require 'xmlsimple'
 @@last_pid = 0
 
 class SpecNamedNode
+  include ActiveFedora::SemanticNode
   include ActiveFedora::RelationshipsHelper
   
   attr_accessor :pid
@@ -51,7 +52,10 @@ describe ActiveFedora::RelationshipsHelper do
     it 'should check if current object is the kind of model class supplied' do
       #has_model relationship does not get created until save called
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNamedNode)})
-      @test_object.expects(:relationships).returns({:self=>{:has_model=>[r.object]}}).at_least_once
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new(r.object))
+      @test_object.expects(:relationships).returns(graph).at_least_once
       @test_object.conforms_to?(SpecNamedNode).should == true
     end
   end
@@ -66,7 +70,10 @@ describe ActiveFedora::RelationshipsHelper do
       @test_object3.pid = increment_pid
       #has_model relationship does not get created until save called so need to add the has model rel here, is fine since not testing save
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNamedNode)}) 
-      @test_object.expects(:relationships).returns({:self=>{:has_model=>[r.object]}}).at_least_once
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new(r.object))
+      @test_object.expects(:relationships).returns(graph).at_least_once
       @test_object3.assert_conforms_to('object',@test_object,SpecNamedNode)
     end
   end
@@ -101,12 +108,19 @@ describe ActiveFedora::RelationshipsHelper do
       @test_object3 = MockNamedRelationships3.new
       @test_object3.pid = increment_pid
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockNamedRelationships3)}) 
-      @test_object2.expects(:relationships).returns({:self=>{:has_model=>[r.object],:has_part=>[],:has_member=>[]},:inbound=>{:has_part=>[]}}).at_least_once
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new(r.object))
+      @test_object2.expects(:relationships).returns(graph).at_least_once
       #should return expected named relationships
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"testing2"=>[]}}
       r3 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object})
-      @test_object3.expects(:relationships).returns({:self=>{:has_model=>[r.object],:has_part=>[r3.object],:has_member=>[]},:inbound=>{:has_part=>[]}}).at_least_once
-      @test_object3.relationships_by_name.should == {:self=>{"testing"=>[r3.object],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new(r.object))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_part),  RDF::URI.new(r3.object))
+      @test_object3.expects(:relationships).returns(graph).at_least_once
+      @test_object3.relationships_by_name.should == {:self=>{"testing"=>[r3.object],"testing2"=>[]}}
     end 
   end
 
@@ -171,7 +185,9 @@ describe ActiveFedora::RelationshipsHelper do
     it 'should return hash of outbound relationship names to arrays of object uri' do
       @test_object2 = MockRelationshipNames.new
       @test_object2.pid = increment_pid
-      @test_object2.expects(:relationships).returns({:self=>{:has_part=>[],:has_member=>[],:inbound=>{:has_part=>[],:has_member=>[]}}}).at_least_once
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      @test_object2.expects(:relationships).returns(graph).at_least_once
       @test_object2.outbound_relationships_by_name.should == {"testing"=>[],
                                                             "testing2"=>[]} 
     end
@@ -198,7 +214,12 @@ describe ActiveFedora::RelationshipsHelper do
       #add relationships that mirror 'testing' and 'testing2'
       r3 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_part, :object=>@test_object3)
       r4 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_member, :object=>@test_object4)      
-      @test_object2.expects(:relationships).returns({:self=>{:has_part=>[r3.object]},:has_member=>[r4.object],:has_model=>[r.object]}).at_least_once
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new(r.object))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_member),  RDF::URI.new(r4.object))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_part),  RDF::URI.new(r3.object))
+      @test_object2.expects(:relationships).returns(graph).at_least_once
      @test_object2.find_relationship_by_name("testing").should == [r3.object] 
     end
   end
@@ -221,18 +242,16 @@ describe ActiveFedora::RelationshipsHelper do
     end
     
     it "should call bidirectional_relationship_query if a bidirectional relationship" do
-      rels_ids = ["info:fedora/changeme:1","info:fedora/changeme:2","info:fedora/changeme:3","info:fedora/changeme:4"]
-      @mockrelsquery.expects(:outbound_relationships).returns({:has_part=>rels_ids}).at_least_once
       ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+      @mockrelsquery.expects(:ids_for_outbound).with(:has_part).returns(ids).at_least_once
       @mockrelsquery.expects(:pid).returns("changeme:5")
       MockNamedRelationshipQuery.expects(:bidirectional_relationship_query).with("changeme:5","testing_bi_query",ids)
       @mockrelsquery.relationship_query("testing_bi_query")
     end
     
     it "should call outbound_relationship_query if an outbound relationship" do
-      rels_ids = ["info:fedora/changeme:1","info:fedora/changeme:2","info:fedora/changeme:3","info:fedora/changeme:4"]
-      @mockrelsquery.expects(:outbound_relationships).returns({:is_part_of=>rels_ids}).at_least_once
       ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+      @mockrelsquery.expects(:ids_for_outbound).with(:is_part_of).returns(ids).at_least_once
       MockNamedRelationshipQuery.expects(:outbound_relationship_query).with("testing_outbound_no_solr_fq",ids)
       @mockrelsquery.relationship_query("testing_outbound_no_solr_fq")
     end

data/spec/unit/rels_ext_datastream_spec.rb

@@ -1,18 +1,11 @@
 require File.join( File.dirname(__FILE__), "../spec_helper" )
 
-require 'active_fedora'
-require "rexml/document"
-require "nokogiri"
-require 'ftools'
+require 'equivalent-xml'
 
 describe ActiveFedora::RelsExtDatastream do
   
   before(:all) do
     @pid = "test:sample_pid"
-    @test_relationship1 = ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "demo:10")  
-    @test_relationship2 = ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_part_of, :object => "demo:11")  
-    @test_relationship3 = ActiveFedora::Relationship.new(:subject => @pid, :predicate => :has_part, :object => "demo:12")  
-    @test_relationship4 = ActiveFedora::Relationship.new(:subject => @pid, :predicate => :conforms_to, :object => "AnInterface", :is_literal=>true)  
   
     @sample_xml = Nokogiri::XML::Document.parse(@sample_xml_string)
   end
@@ -33,36 +26,65 @@ describe ActiveFedora::RelsExtDatastream do
   describe '#serialize!' do
     
     it "should generate new rdf/xml as the datastream content if the object has been changed" do
-      @test_ds.register_triple(:self, :is_member_of, "demo:10") 
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_member_of),  RDF::URI.new('demo:10'))
+      
+      @test_ds.expects(:model).returns(stub("model", :outbound_relationships=>graph, :relationships=>graph,  :relationships_are_dirty =>true, :relationships_are_dirty= => true)).times(3)
       @test_ds.serialize!
-      @test_ds.content.should == "      <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n        <rdf:Description rdf:about='info:fedora/test:sample_pid'>\n        <isMemberOf rdf:resource='demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/></rdf:Description>\n      </rdf:RDF>\n"
+      EquivalentXml.equivalent?(@test_ds.content, "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n        <rdf:Description rdf:about='info:fedora/test:sample_pid'>\n        <isMemberOf rdf:resource='demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/></rdf:Description>\n      </rdf:RDF>").should be_true
     end
   
   end
+
+  describe '#to_rels_ext' do
+    
+    before(:all) do
+      @sample_rels_ext_xml = <<-EOS
+      <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
+        <rdf:Description rdf:about='info:fedora/test:sample_pid'>
+          <isMemberOf rdf:resource='info:fedora/demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/>
+          <isPartOf rdf:resource='info:fedora/demo:11' xmlns='info:fedora/fedora-system:def/relations-external#'/>
+          <hasPart rdf:resource='info:fedora/demo:12' xmlns='info:fedora/fedora-system:def/relations-external#'/>
+          <hasModel rdf:resource='info:fedora/afmodel:OtherModel' xmlns='info:fedora/fedora-system:def/model#'/>
+          <hasModel rdf:resource='info:fedora/afmodel:SampleModel' xmlns='info:fedora/fedora-system:def/model#'/>
+        </rdf:Description>
+      </rdf:RDF>
+      EOS
+      @pid = "test:sample_pid"
+    end
+    
+    it 'should serialize the relationships array to Fedora RELS-EXT rdf/xml' do
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:OtherModel"))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_model),  RDF::URI.new("info:fedora/afmodel:SampleModel"))
+
+      @test_ds.expects(:model).returns(stub("model", :relationships=>graph, :relationships_are_dirty= => true))
+      EquivalentXml.equivalent?(@test_ds.to_rels_ext(), @sample_rels_ext_xml).should be_true
+    end
+    
+  end
   
   describe "#from_xml" do
     before(:all) do
       @test_obj = ActiveFedora::Base.new
-      @test_obj.add_relationship(:is_member_of, "demo:10")
-      @test_obj.add_relationship(:is_part_of, "demo:11")
+      @test_obj.add_relationship(:is_member_of, "info:fedora/demo:10")
+      @test_obj.add_relationship(:is_part_of, "info:fedora/demo:11")
       @test_obj.add_relationship(:conforms_to, "AnInterface", true)
       @test_obj.save
     end
     after(:all) do
       @test_obj.delete
     end
-    it "should load RELS-EXT relationships into relationships hash" do
-      @test_obj.relationships.should == {:self=>{:is_member_of=>["info:fedora/demo:10"], :is_part_of=>["info:fedora/demo:11"], :has_model=>["info:fedora/afmodel:ActiveFedora_Base"], :conforms_to=>["AnInterface"]}}
-      new_ds = ActiveFedora::RelsExtDatastream.new(nil, nil)
-      new_ds.relationships.should == {:self=>{}}
-      ActiveFedora::RelsExtDatastream.from_xml(@test_obj.rels_ext.content,new_ds)
-      new_ds.relationships.should == @test_obj.relationships
-    end
     it "should handle un-mapped predicates gracefully" do
-      @test_obj.relationships.should == {:self=>{:is_member_of=>["info:fedora/demo:10"], :is_part_of=>["info:fedora/demo:11"], :has_model=>["info:fedora/afmodel:ActiveFedora_Base"], :conforms_to=>["AnInterface"]}}
       @test_obj.add_relationship("foo", "foo:bar")
       @test_obj.save
-      @test_obj.relationships.should == {:self=>{:is_part_of=>["info:fedora/demo:11"], "foo"=>["info:fedora/foo:bar"], :has_model=>["info:fedora/afmodel:ActiveFedora_Base"], :is_member_of=>["info:fedora/demo:10"], :conforms_to=>["AnInterface"]}}
+      @test_obj.relationships.size.should == 5 
+      @test_obj.ids_for_outbound("foo").should == ["foo:bar"]
     end
     it "should handle un-mapped literals" do
       pending
@@ -93,15 +115,23 @@ describe ActiveFedora::RelsExtDatastream do
   describe ".to_solr" do
     
     it "should provide .to_solr and return a SolrDocument" do
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_member_of),  RDF::URI.new('demo:10'))
       @test_ds.should respond_to(:to_solr)
+      @test_ds.expects(:model).returns(stub("model", :relationships=>graph, :relationships_are_dirty= => true))
       @test_ds.to_solr.should be_kind_of(Hash)
     end
     
     it "should serialize the relationships into a Hash" do
-      @test_ds.add_relationship(@test_relationship1)
-      @test_ds.add_relationship(@test_relationship2)
-      @test_ds.add_relationship(@test_relationship3)
-      @test_ds.add_relationship(@test_relationship4)
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_member_of),  RDF::URI.new('info:fedora/demo:10'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:is_part_of),  RDF::URI.new('info:fedora/demo:11'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:has_part),  RDF::URI.new('info:fedora/demo:12'))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Base.new.find_graph_predicate(:conforms_to),  "AnInterface")
+
+      @test_ds.expects(:model).returns(stub("model", :relationships=>graph, :relationships_are_dirty= => true))
       solr_doc = @test_ds.to_solr
       solr_doc["is_member_of_s"].should == ["info:fedora/demo:10"]
       solr_doc["is_part_of_s"].should == ["info:fedora/demo:11"]

data/spec/unit/semantic_node_spec.rb

@@ -156,13 +156,13 @@ describe ActiveFedora::SemanticNode do
     it "should add a subject and predicate to the relationships array" do
       SpecNode.has_relationship("parents", :is_part_of)
       SpecNode.relationships.should have_key(:self)
-      @node.relationships[:self].should have_key(:is_part_of)
+      SpecNode.relationships[:self].should have_key(:is_part_of)
     end
     
     it "should use :inbound as the subject if :inbound => true" do
       SpecNode.has_relationship("parents", :is_part_of, :inbound => true)
       SpecNode.relationships.should have_key(:inbound)
-      @node.relationships[:inbound].should have_key(:is_part_of)
+      SpecNode.relationships[:inbound].should have_key(:is_part_of)
     end
     
     it 'should create inbound relationship finders' do
@@ -181,8 +181,12 @@ describe ActiveFedora::SemanticNode do
       local_node = SpecNode.new
       local_node.internal_uri = "info:fedora/#{@pid}"
       
-      local_node.add_relationship(ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/container:A") )
-      local_node.add_relationship(ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/container:B") )
+      # local_node.add_relationship(ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/container:A") )
+      # local_node.add_relationship(ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "info:fedora/container:B") )
+      local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true)).twice
+      local_node.add_relationship(:is_member_of, "info:fedora/container:A")
+      local_node.add_relationship(:is_member_of, "info:fedora/container:B")
+
       containers_result = local_node.containers_ids
       containers_result.should be_instance_of(Array)
       containers_result.should include("container:A")
@@ -227,8 +231,8 @@ describe ActiveFedora::SemanticNode do
       @test_object2 = MockHasRelationship.new
       @test_object2.pid = increment_pid
       @test_object2.stubs(:testing_inbound).returns({})
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2)})
-      @test_object2.add_relationship(r)
+      @test_object2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true))
+      @test_object2.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2))
       @test_object2.should respond_to(:testing_append)
       @test_object2.should respond_to(:testing_remove)
       @test_object2.should respond_to(:testing2_append)
@@ -343,7 +347,7 @@ describe ActiveFedora::SemanticNode do
       it "should read from relationships array and use Repository.find_model to build an array of objects" do
         SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
         local_node = SpecNode.new
-        local_node.expects(:outbound_relationships).returns({:is_member_of => ["my:_PID1_", "my:_PID2_", "my:_PID3_"]}).times(2)      
+        local_node.expects(:ids_for_outbound).with(:is_member_of).returns(["my:_PID1_", "my:_PID2_", "my:_PID3_"])
         mock_repo = mock("repo")
         solr_result = mock("solr result", :is_a? => true)
         solr_result.expects(:hits).returns(
@@ -369,14 +373,15 @@ describe ActiveFedora::SemanticNode do
       it "(:response_format => :id_array) should read from relationships array" do
         SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
         local_node = SpecNode.new
-        local_node.expects(:outbound_relationships).returns({:is_member_of => []}).times(2)
+        local_node.expects(:ids_for_outbound).with(:is_member_of).returns([])
         local_node.containers_ids
       end
     
       it "(:response_format => :id_array) should return an array of fedora PIDs" do
         SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
         local_node = SpecNode.new
-        local_node.add_relationship(@test_relationship1)
+        local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true))
+        local_node.add_relationship(@test_relationship1.predicate, @test_relationship1.object)
         result = local_node.containers_ids
         result.should be_instance_of(Array)
         result.should include("demo:10")
@@ -433,8 +438,8 @@ describe ActiveFedora::SemanticNode do
     end
 
     it "should register both inbound and outbound predicate components" do
-      @local_node.relationships[:inbound].has_key?(:is_part_of).should == true
-      @local_node.relationships[:self].has_key?(:has_part).should == true
+      @local_node.class.relationships[:inbound].has_key?(:is_part_of).should == true
+      @local_node.class.relationships[:self].has_key?(:has_part).should == true
     end
   
     it "should register relationship names for inbound, outbound" do
@@ -470,35 +475,38 @@ describe ActiveFedora::SemanticNode do
       @local_node2 = SpecNode.new
       @local_node2.pid = "mypid2"
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode)}) 
-      @local_node.add_relationship(r)
-      @local_node2.add_relationship(r)
+      @local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true)).twice
+      @local_node.add_relationship(r.predicate, r.object)
+      @local_node2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true)).twice
+      @local_node2.add_relationship(r.predicate, r.object)
       r2 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@local_node2})
-      @local_node.add_relationship(r2)
+      @local_node.add_relationship(r2.predicate, r2.object)
       r3 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@local_node})
-      @local_node2.add_relationship(r3)
-      @local_node.relationships.should == {:self=>{:has_model=>[r.object],:has_part=>[r2.object]},:inbound=>{:is_part_of=>[]}}
-      @local_node2.relationships.should == {:self=>{:has_model=>[r.object],:has_part=>[r3.object]},:inbound=>{:is_part_of=>[]}}
-      @local_node.relationships_by_name.should == {:self=>{"all_parts_outbound"=>[r2.object]},:inbound=>{"all_parts_inbound"=>[]}}
-      @local_node2.relationships_by_name.should == {:self=>{"all_parts_outbound"=>[r3.object]},:inbound=>{"all_parts_inbound"=>[]}}
+      @local_node2.add_relationship(r3.predicate, r3.object)
+      @local_node.ids_for_outbound(:has_part).should == [@local_node2.pid]
+      @local_node.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
+      @local_node2.ids_for_outbound(:has_part).should == [@local_node.pid]
+      @local_node2.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
+      @local_node.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[r2.object]},:inbound=>{"all_parts_inbound"=>[]}}
+      @local_node2.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[r3.object]},:inbound=>{"all_parts_inbound"=>[]}}
     end
   end
   
   describe ".add_relationship" do
     it "should add relationship to the relationships hash" do
-      @node.add_relationship(@test_relationship)
-      @node.relationships.should have_key(@test_relationship.subject) 
-      @node.relationships[@test_relationship.subject].should have_key(@test_relationship.predicate)
-      @node.relationships[@test_relationship.subject][@test_relationship.predicate].should include(@test_relationship.object)
+      @node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true))
+      @node.add_relationship(@test_relationship.predicate, @test_relationship.object)
+      @node.ids_for_outbound("isMemberOf").should == ['demo:9']
     end
     
     it "adding relationship to an instance should not affect class-level relationships hash" do 
       local_test_node1 = SpecNode.new
       local_test_node2 = SpecNode.new
-      local_test_node1.add_relationship(@test_relationship1)
-      #local_test_node2.add_relationship(@test_relationship2)
+      local_test_node1.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true))
+      local_test_node1.add_relationship(@test_relationship1.predicate, @test_relationship1.object)
       
-      local_test_node1.relationships[:self][:is_member_of].should == ["info:fedora/demo:10"]      
-      local_test_node2.relationships[:self][:is_member_of].should be_nil
+      local_test_node1.ids_for_outbound(:is_member_of).should == ["demo:10"]
+      local_test_node2.ids_for_outbound(:is_member_of).should == []
     end
     
   end
@@ -518,12 +526,10 @@ describe ActiveFedora::SemanticNode do
       
   describe '.register_triple' do
     it 'should add triples to the relationships hash' do
-      @node.register_triple(:self, :is_part_of, "info:fedora/demo:10")
-      @node.register_triple(:self, :is_member_of, "info:fedora/demo:11")
-      @node.relationships[:self].should have_key(:is_part_of)
-      @node.relationships[:self].should have_key(:is_member_of)
-      @node.relationships[:self][:is_part_of].should include("info:fedora/demo:10")
-      @node.relationships[:self][:is_member_of].should include("info:fedora/demo:11")
+      @node.register_triple(@node.internal_uri, :is_part_of, "info:fedora/demo:10")
+      @node.register_triple(@node.internal_uri, :is_member_of, "info:fedora/demo:11")
+      @node.ids_for_outbound(:is_part_of).should == ['demo:10'] 
+      @node.ids_for_outbound(:is_member_of).should == ['demo:11'] 
     end
     
     it "should not be a class level method"
@@ -541,121 +547,46 @@ describe ActiveFedora::SemanticNode do
     lambda { SpecNode.predicate_lookup(:has_foo) }.should raise_error ActiveFedora::UnregisteredPredicateError
   end
   
-  it 'should provide #relationships_to_rels_ext' do
-    SpecNode.should respond_to(:relationships_to_rels_ext)
-    @node.should respond_to(:to_rels_ext)
-  end
-  
-  describe '#relationships_to_rels_ext' do
-    
-    before(:all) do
-      @sample_rels_ext_xml = <<-EOS
-      <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>
-        <rdf:Description rdf:about='info:fedora/test:sample_pid'>
-          <isMemberOf rdf:resource='info:fedora/demo:10' xmlns='info:fedora/fedora-system:def/relations-external#'/>
-          <isPartOf rdf:resource='info:fedora/demo:11' xmlns='info:fedora/fedora-system:def/relations-external#'/>
-          <hasPart rdf:resource='info:fedora/demo:12' xmlns='info:fedora/fedora-system:def/relations-external#'/>
-          <hasModel rdf:resource='info:fedora/afmodel:OtherModel' xmlns='info:fedora/fedora-system:def/model#'/>
-          <hasModel rdf:resource='info:fedora/afmodel:SampleModel' xmlns='info:fedora/fedora-system:def/model#'/>
-        </rdf:Description>
-      </rdf:RDF>
-      EOS
-    end
-    
-    it 'should serialize the relationships array to Fedora RELS-EXT rdf/xml' do
-      @node.add_relationship(@test_relationship1)
-      @node.add_relationship(@test_relationship2)
-      @node.add_relationship(@test_relationship3)
-      @node.add_relationship(@test_cmodel_relationship1)
-      @node.add_relationship(@test_cmodel_relationship2)
-      @node.internal_uri = @uri
-      # returned_xml = XmlSimple.xml_in(@node.to_rels_ext(@pid))
-      # returned_xml.should == XmlSimple.xml_in(@sample_rels_ext_xml)
-      EquivalentXml.equivalent?(@node.to_rels_ext(@pid), @sample_rels_ext_xml).should be_true
-    end
-    
-    it "should treat :self and self.pid as equivalent subjects"
-  end
-  
-  it 'should provide #relationships_to_rdf_xml' 
-
-  describe '#relationships_to_rdf_xml' do
-    it 'should serialize the relationships array to rdf/xml'
-  end
   
   it "should provide .outbound_relationships" do 
     @node.should respond_to(:outbound_relationships)
   end
   
     
-  it 'should provide #unregister_triple' do
-    @test_object.should respond_to(:unregister_triple)
-  end
-  
-  describe '#unregister_triple' do
-    it 'should remove a triple from the relationships hash' do
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>"info:fedora/3"})
-      r2 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>"info:fedora/4"})
-      @test_object.add_relationship(r)
-      @test_object.add_relationship(r2)
-      #check both are there
-      @test_object.relationships.should == {:self=>{:has_part=>[r.object,r2.object]}}
-      @test_object.unregister_triple(r.subject,r.predicate,r.object)
-      #check returns false if relationship does not exist and does nothing
-      @test_object.unregister_triple(:self,:has_member,r2.object).should == false
-      #check only one item removed
-      @test_object.relationships.should == {:self=>{:has_part=>[r2.object]}}
-      @test_object.unregister_triple(r2.subject,r2.predicate,r2.object)
-      #check last item removed and predicate removed since now emtpy
-      @test_object.relationships.should == {:self=>{}}
-      
-    end
-  end
-
-  it 'should provide #remove_relationship' do
-    @test_object.should respond_to(:remove_relationship)
-  end
-
   describe '#remove_relationship' do
     it 'should remove a relationship from the relationships hash' do
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>"info:fedora/3"})
       r2 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>"info:fedora/4"})
-      @test_object.add_relationship(r)
-      @test_object.add_relationship(r2)
+      @test_object.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true)).times(5)
+      @test_object.add_relationship(r.predicate, r.object)
+      @test_object.add_relationship(r2.predicate, r2.object)
       #check both are there
-      @test_object.relationships.should == {:self=>{:has_part=>[r.object,r2.object]}}
-      @test_object.remove_relationship(r)
+      @test_object.ids_for_outbound(:has_part).should include "3", "4"
+      @test_object.remove_relationship(r.predicate, r.object)
       #check returns false if relationship does not exist and does nothing with different predicate
       rBad = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_member,:object=>"info:fedora/4"})
-      @test_object.remove_relationship(rBad).should == false
+      @test_object.remove_relationship(rBad.predicate, rBad.object)
       #check only one item removed
-      @test_object.relationships.should == {:self=>{:has_part=>[r2.object]}}
-      @test_object.remove_relationship(r2)
+      @test_object.ids_for_outbound(:has_part).should == ['4']
+      @test_object.remove_relationship(r2.predicate, r2.object)
       #check last item removed and predicate removed since now emtpy
-      @test_object.relationships.should == {:self=>{}}
+      @test_object.ids_for_outbound(:has_part).should == []
       
     end
   end
   
-  it 'should provide #relationship_exists?' do
-    @test_object.should respond_to(:relationship_exists?)
-  end
-  
   describe '#relationship_exists?' do
     it 'should return true if a relationship does exist' do
       @test_object3 = SpecNode2.new
       @test_object3.pid = increment_pid
       r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_member,:object=>@test_object3})
-      @test_object.relationship_exists?(r.subject,r.predicate,r.object).should == false
-      @test_object.add_relationship(r)
-      @test_object.relationship_exists?(r.subject,r.predicate,r.object).should == true
+      @test_object.relationship_exists?(@test_object.internal_uri,r.predicate,r.object).should == false
+      @test_object.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true))
+      @test_object.add_relationship(r.predicate, r.object)
+      @test_object.relationship_exists?(@test_object.internal_uri,r.predicate,r.object).should == true
     end
   end
 
-  it 'should provide #assert_kind_of' do
-    @test_object.should respond_to(:assert_kind_of)
-  end
-
   describe '#assert_kind_of' do
     it 'should raise an exception if object supplied is not the correct type' do
       had_exception = false