active-fedora 2.3.4 → 2.3.7

data/spec/unit/semantic_node_spec.rb

@@ -138,10 +138,12 @@ describe ActiveFedora::SemanticNode do
       SpecNode.has_relationship("parts", :is_part_of, :inbound => true)
       local_node = SpecNode.new
       local_node.should respond_to(:parts_ids)
+      local_node.should respond_to(:parts_query)
       # local_node.should respond_to(:parts)
       local_node.should_not respond_to(:containers)
       SpecNode.has_relationship("containers", :is_member_of)  
       local_node.should respond_to(:containers_ids)
+      local_node.should respond_to(:containers_query)
     end
     
     it "should add a subject and predicate to the relationships array" do
@@ -187,6 +189,7 @@ describe ActiveFedora::SemanticNode do
     end
       
     #can only duplicate predicates if not both inbound or not both outbound
+=begin
     class MockHasRelationshipDuplicatePredicate < SpecNode2
       has_relationship "testing", :has_member, :type=>SpecNode2
       had_exception = false
@@ -197,7 +200,9 @@ describe ActiveFedora::SemanticNode do
       end
       raise "Did not raise exception if duplicate predicate used" unless had_exception 
     end
-      
+=end
+
+=begin      
     #can only duplicate predicates if not both inbound or not both outbound
     class MockHasRelationshipDuplicatePredicate2 < SpecNode2
       has_relationship "testing", :has_member, :type=>SpecNode2, :inbound=>true
@@ -209,6 +214,7 @@ describe ActiveFedora::SemanticNode do
       end
       raise "Did not raise exception if duplicate predicate used" unless had_exception 
     end
+=end
       
     it 'should create relationship descriptions both inbound and outbound' do
       @test_object2 = MockHasRelationship.new
@@ -224,7 +230,7 @@ describe ActiveFedora::SemanticNode do
       @test_object2.should_not respond_to(:testing_inbound_append)
       @test_object2.should_not respond_to(:testing_inbound_remove)
       
-      @test_object2.named_relationships_desc.should == 
+      @test_object2.relationships_desc.should == 
       {:inbound=>{"testing_inbound"=>{:type=>SpecNode2, 
                                      :predicate=>:has_part, 
                                       :inbound=>true, 
@@ -255,6 +261,7 @@ describe ActiveFedora::SemanticNode do
       local_node.should respond_to(:containers_ids)
       local_node.should respond_to(:containers)
       local_node.should respond_to(:containers_from_solr)
+      local_node.should respond_to(:containers_query)
     end
     
     it "resulting finder should search against solr and use Model#load_instance to build an array of objects" do
@@ -265,7 +272,8 @@ describe ActiveFedora::SemanticNode do
       mock_repo.expects(:find_model).with("_PID3_", "AudioRecord").returns("AR3")
       SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
       local_node = SpecNode.new()
-      local_node.expects(:internal_uri).returns("info:fedora/test:sample_pid")
+      local_node.expects(:pid).returns("test:sample_pid")
+      SpecNode.expects(:relationships_desc).returns({:inbound=>{"parts"=>{:predicate=>:is_part_of}}}).at_least_once()
       ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid", :rows=>25).returns(solr_result)
       Fedora::Repository.expects(:instance).returns(mock_repo).times(3)
       Kernel.expects(:const_get).with("AudioRecord").returns("AudioRecord").times(3)
@@ -278,7 +286,8 @@ describe ActiveFedora::SemanticNode do
       local_node = SpecNode.new
       mock_repo = mock("repo")
       mock_repo.expects(:find_model).never
-      local_node.expects(:internal_uri).returns("info:fedora/test:sample_pid")
+      local_node.expects(:pid).returns("test:sample_pid")
+      SpecNode.expects(:relationships_desc).returns({:inbound=>{"constituents"=>{:predicate=>:is_constituent_of}}}).at_least_once()
       ActiveFedora::SolrService.instance.conn.expects(:query).with("is_constituent_of_s:info\\:fedora/test\\:sample_pid", :rows=>101).returns(solr_result)
       local_node.constituents(:response_format => :solr, :rows=>101).should equal(solr_result)
     end
@@ -287,7 +296,8 @@ describe ActiveFedora::SemanticNode do
     it "resulting _ids finder should search against solr and return an array of fedora PIDs" do
       SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
       local_node = SpecNode.new
-      local_node.expects(:internal_uri).returns("info:fedora/test:sample_pid")
+      local_node.expects(:pid).returns("test:sample_pid")
+      SpecNode.expects(:relationships_desc).returns({:inbound=>{"parts"=>{:predicate=>:is_part_of}}}).at_least_once() 
       ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid", :rows=>25).returns(mock("solr result", :hits => [Hash["id"=>"pid1"], Hash["id"=>"pid2"]]))
       local_node.parts(:response_format => :id_array).should == ["pid1", "pid2"]
     end
@@ -298,6 +308,13 @@ describe ActiveFedora::SemanticNode do
       local_node.expects(:parts).with(:response_format => :id_array)
       local_node.parts_ids
     end
+
+    it "resulting _query finder should call relationship_query" do
+      SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
+      local_node = SpecNode.new
+      local_node.expects(:relationship_query).with("parts")
+      local_node.parts_query
+    end
     
     it "resulting finder should provide option of filtering results by :type"
   end
@@ -318,6 +335,7 @@ describe ActiveFedora::SemanticNode do
       local_node.should respond_to(:containers_ids)
       local_node.should respond_to(:containers)  
       local_node.should respond_to(:containers_from_solr)  
+      local_node.should respond_to(:containers_query)
     end
     
     describe " resulting finder" do
@@ -374,6 +392,13 @@ describe ActiveFedora::SemanticNode do
         local_node.parts_ids
       end
     end
+
+    it "resulting _query finder should call relationship_query" do
+      SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
+      local_node = SpecNode.new
+      local_node.expects(:relationship_query).with("containers")
+      local_node.containers_query
+    end
   end
   
   describe ".create_bidirectional_relationship_finder" do
@@ -399,10 +424,10 @@ describe ActiveFedora::SemanticNode do
     end
     it "(:response_format => :solr) should construct a solr query that combines inbound and outbound searches" do
       # get the id array for outbound relationships then construct solr query by combining id array with inbound relationship search
-      @local_node.expects(:all_parts_outbound).with(:response_format=>:id_array).returns(["mypid:1"])
+      @local_node.expects(:outbound_relationships).returns({:has_part=>["mypid:1"]}).at_least_once()
       id_array_query = ActiveFedora::SolrService.construct_query_for_pids(["mypid:1"])
       solr_result = mock("solr result")
-      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid OR #{id_array_query}", :rows=>25).returns(solr_result)
+      ActiveFedora::SolrService.instance.conn.expects(:query).with("#{id_array_query} OR (is_part_of_s:info\\:fedora/test\\:sample_pid)", :rows=>25).returns(solr_result)
       @local_node.all_parts(:response_format=>:solr)
     end
 
@@ -416,6 +441,19 @@ describe ActiveFedora::SemanticNode do
       @local_node.relationship_names.include?("all_parts_outbound").should == true
     end
 
+    it "should register finder methods for the bidirectional relationship name" do
+      @local_node.should respond_to(:all_parts)
+      @local_node.should respond_to(:all_parts_ids)
+      @local_node.should respond_to(:all_parts_query)
+      @local_node.should respond_to(:all_parts_from_solr)
+    end
+
+    it "resulting _query finder should call relationship_query" do
+      SpecNode.create_bidirectional_relationship_finders("containers", :is_member_of, :has_member)
+      local_node = SpecNode.new
+      local_node.expects(:relationship_query).with("containers")
+      local_node.containers_query
+    end
   end
   
   describe "#has_bidirectional_relationship" do
@@ -424,7 +462,7 @@ describe ActiveFedora::SemanticNode do
       SpecNode.has_bidirectional_relationship("all_parts", :has_part, :is_part_of)
     end
 
-    it "should have named_relationship and relationship hashes contain bidirectionally related objects" do
+    it "should have relationships_by_name and relationships hashes contain bidirectionally related objects" do
       SpecNode.has_bidirectional_relationship("all_parts", :has_part, :is_part_of)
       @local_node = SpecNode.new
       @local_node.pid = "mypid1"
@@ -439,8 +477,8 @@ describe ActiveFedora::SemanticNode do
       @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.named_relationships.should == {:self=>{"all_parts_outbound"=>[r2.object]},:inbound=>{"all_parts_inbound"=>[]}}
-      @local_node2.named_relationships.should == {:self=>{"all_parts_outbound"=>[r3.object]},:inbound=>{"all_parts_inbound"=>[]}}
+      @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"=>[]}}
     end
   end
   
@@ -597,82 +635,6 @@ describe ActiveFedora::SemanticNode do
       
     end
   end
-
-  it 'should provide #named_relationship_predicates' do
-    @test_object.should respond_to(:named_relationship_predicates)
-  end
-  
-  describe '#named_relationship_predicates' do
-    class MockNamedRelationshipPredicates < SpecNode2
-      has_relationship "testing", :has_part, :type=>SpecNode2
-      has_relationship "testing2", :has_member, :type=>SpecNode2
-      has_relationship "testing_inbound", :has_part, :type=>SpecNode2, :inbound=>true
-    end
-    
-    it 'should return a map of subject to relationship name to fedora ontology relationship predicate' do
-      @test_object2 = MockNamedRelationshipPredicates.new
-      @test_object2.pid = increment_pid
-      model_rel = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockNamedRelationshipPredicates)}) 
-      @test_object2.add_relationship(model_rel)
-      @test_object3 = SpecNode2.new
-      @test_object3.pid = increment_pid
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2)}) 
-      @test_object3.add_relationship(r)
-      @test_object4 = SpecNode2.new 
-      @test_object4.pid = increment_pid
-      @test_object4.add_relationship(r)
-      @test_object.add_relationship(r)
-      #create relationships that mirror "testing"
-      r3 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object3})
-      r4 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object4})
-      @test_object2.add_relationship(r3)
-      @test_object2.add_relationship(r4)
-      #create relationship mirroring testing2
-      r5 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_member,:object=>@test_object})
-      @test_object2.add_relationship(r5)
-      @test_object2.named_relationship_predicates.should == {:self=>{"testing"=>:has_part,"testing2"=>:has_member},
-                                                            :inbound=>{"testing_inbound"=>:has_part}}
-      
-    end 
-  end
-
-   it 'should provide #kind_of_model?' do
-    @test_object.should respond_to(:kind_of_model?)
-  end
-  
-  describe '#kind_of_model?' 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(SpecNode2)}) 
-      @test_object.add_relationship(r)
-      @test_object.kind_of_model?(SpecNode2).should == true
-    end
-  end
-  
-  it 'should provide #assert_kind_of_model' do
-    @test_object.should respond_to(:assert_kind_of_model)
-  end
-  
-  describe '#assert_kind_of_model' do
-    it 'should correctly assert if an object is the type of model supplied' do
-      @test_object3 = SpecNode2.new
-      @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(SpecNode2)}) 
-      @test_object.add_relationship(r)
-      @test_object3.assert_kind_of_model('object',@test_object,SpecNode2)
-    end
-  end
-  
-  it 'should provide #class_from_name' do
-    @test_object.should respond_to(:class_from_name)
-  end
-  
-  describe '#class_from_name' do
-    it 'should return a class constant for a string passed in' do
-      @test_object.class_from_name("SpecNode2").should == SpecNode2
-    end
-  end
   
   it 'should provide #relationship_exists?' do
     @test_object.should respond_to(:relationship_exists?)
@@ -689,54 +651,10 @@ describe ActiveFedora::SemanticNode do
     end
   end
 
-  it 'should provide #named_relationships' do
-    @test_object.should respond_to(:named_relationships)
-  end
-  
-  describe '#named_relationships' do
-    
-    class MockNamedRelationships3 < SpecNode2
-      has_relationship "testing", :has_part, :type=>SpecNode2
-      has_relationship "testing2", :has_member, :type=>SpecNode2
-      has_relationship "testing_inbound", :has_part, :type=>SpecNode2, :inbound=>true
-    end
-    
-    it 'should return current named relationships' do
-      @test_object2 = MockNamedRelationships3.new
-      @test_object2.pid = increment_pid
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockNamedRelationships3)}) 
-      @test_object2.add_relationship(r)
-      r2 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2)}) 
-      @test_object.add_relationship(r2)
-      #should return expected named relationships
-      @test_object2.named_relationships.should == {:self=>{"testing"=>[],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
-      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object})
-      @test_object2.add_relationship(r)
-      @test_object2.named_relationships.should == {:self=>{"testing"=>[r.object],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
-    end 
-
-    it 'should automatically update the named_relationships if relationships has changed (no refresh of named_relationships hash unless relationships hash has changed)' 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_object3.add_relationship(r)
-      r2 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2)}) 
-      @test_object.add_relationship(r2)
-      #should return expected named relationships
-      @test_object3.named_relationships.should == {:self=>{"testing"=>[],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
-      r3 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_part,:object=>@test_object})
-      @test_object3.add_relationship(r3)
-      @test_object3.named_relationships.should == {:self=>{"testing"=>[r3.object],"testing2"=>[]},:inbound=>{"testing_inbound"=>[]}}
-      r4 = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_member,:object=>"3"})
-      @test_object3.add_relationship(r4)
-      @test_object3.named_relationships.should == {:self=>{"testing"=>[r3.object],"testing2"=>[r4.object]},:inbound=>{"testing_inbound"=>[]}}
-    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
@@ -750,196 +668,4 @@ describe ActiveFedora::SemanticNode do
       @test_object.assert_kind_of 'SpecNode2', @test_object, SpecNode2
     end
   end
-
-  it 'should provide #relationship_names' do
-    @test_object.should respond_to(:relationship_names)
-  end
-  
-  describe '#relationship_names' do
-    class MockRelationshipNames < SpecNode2
-      has_relationship "testing", :has_part, :type=>SpecNode2
-      has_relationship "testing2", :has_member, :type=>SpecNode2
-      has_relationship "testing_inbound", :has_part, :type=>SpecNode2, :inbound=>true
-      has_relationship "testing_inbound2", :has_member, :type=>SpecNode2, :inbound=>true
-    end
-    
-    it 'should return an array of relationship names for this model' do
-      @test_object2 = MockRelationshipNames.new
-      @test_object2.pid = increment_pid
-      @test_object2.relationship_names.include?("testing").should == true
-      @test_object2.relationship_names.include?("testing2").should == true
-      @test_object2.relationship_names.include?("testing_inbound").should == true
-      @test_object2.relationship_names.include?("testing_inbound2").should == true
-      @test_object2.relationship_names.size.should == 4
-    end
-  end
-  
-  it 'should provide #inbound_relationship_names' do
-    @test_object.should respond_to(:inbound_relationship_names)
-  end
-  
-  describe '#inbound_relationship_names' do
-    it 'should return an array of inbound relationship names for this model' do
-      @test_object2 = MockRelationshipNames.new
-      @test_object2.pid = increment_pid
-      @test_object2.inbound_relationship_names.include?("testing_inbound").should == true
-      @test_object2.inbound_relationship_names.include?("testing_inbound2").should == true
-      @test_object2.inbound_relationship_names.size.should == 2
-    end
-  end
-  
-  it 'should provide #outbound_relationship_names' do
-    @test_object.should respond_to(:outbound_relationship_names)
-  end
-  
-  describe '#outbound_relationship_names' do
-    it 'should return an array of outbound relationship names for this model' do
-      @test_object2 = MockRelationshipNames.new
-      @test_object2.pid = increment_pid
-      @test_object2.outbound_relationship_names.include?("testing").should == true
-      @test_object2.outbound_relationship_names.include?("testing2").should == true
-      @test_object2.outbound_relationship_names.size.should == 2
-    end
-  end
-  
-  it 'should provide #named_outbound_relationships' do
-    @test_object.should respond_to(:named_outbound_relationships)
-  end
-  
-  describe '#named_outbound_relationships' 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.named_outbound_relationships.should == {"testing"=>[],
-                                                            "testing2"=>[]} 
-    end
-  end
-  
-  it 'should provide #named_inbound_relationships' do
-    #testing execution of this in integration since touches solr
-    @test_object.should respond_to(:named_inbound_relationships)
-  end
-  
-  it 'should provide #named_relationship' do
-    @test_object.should respond_to(:named_relationship)
-  end
-  
-  describe '#named_relationship' do
-    it 'should return an array of object uri for a given relationship name' do
-      @test_object2 = MockRelationshipNames.new
-      @test_object2.pid = increment_pid
-      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_model, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(MockRelationshipNames))
-      @test_object2.add_relationship(r)
-      @test_object3 = SpecNode2.new 
-      @test_object3.pid = increment_pid
-      r2 = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:has_model, :object=>ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode2))
-      @test_object3.add_relationship(r2)
-      @test_object4 = SpecNode2.new 
-      @test_object4.pid = increment_pid
-      @test_object4.add_relationship(r2)
-      @test_object.add_relationship(r2)
-      #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.add_relationship(r3)
-      @test_object2.add_relationship(r4)
-     @test_object2.named_relationship("testing").should == [r3.object] 
-    end
-  end
-  
-  describe ActiveFedora::SemanticNode::ClassMethods do
-    
-    after(:each) do
-      begin
-        @test_object2.delete
-      rescue
-      end
-    end
-    
-    describe '#named_relationships_desc' do
-      it 'should initialize named_relationships_desc to a new hash containing self' do
-        @test_object2 = SpecNode2.new
-        @test_object2.pid = increment_pid
-        @test_object2.named_relationships_desc.should == {:self=>{}}
-      end
-    end
-      
-    describe '#register_named_subject' do
-    
-      class MockRegisterNamedSubject < SpecNode2
-        register_named_subject :test
-      end
-    
-      it 'should add a new named subject to the named relationships only if it does not already exist' do
-        @test_object2 = MockRegisterNamedSubject.new
-        @test_object2.pid = increment_pid
-        @test_object2.named_relationships_desc.should == {:self=>{}, :test=>{}}
-      end 
-    end
-  
-    describe '#register_named_relationship' do
-    
-      class MockRegisterNamedRelationship < SpecNode2
-        register_named_relationship :self, "testing", :is_part_of, :type=>SpecNode2
-        register_named_relationship :inbound, "testing2", :has_part, :type=>SpecNode2
-      end
-    
-      it 'should add a new named subject to the named relationships only if it does not already exist' do
-        @test_object2 = MockRegisterNamedRelationship.new 
-        @test_object2.pid = increment_pid
-        @test_object2.named_relationships_desc.should == {:inbound=>{"testing2"=>{:type=>SpecNode2, :predicate=>:has_part}}, :self=>{"testing"=>{:type=>SpecNode2, :predicate=>:is_part_of}}}
-      end 
-    end
-    
-    describe '#create_named_relationship_methods' do
-      class MockCreateNamedRelationshipMethods < SpecNode2
-        register_named_relationship :self, "testing", :is_part_of, :type=>SpecNode2
-        create_named_relationship_methods "testing"
-      end
-      
-      it 'should create an append and remove method for each outbound relationship' do
-        @test_object2 = MockCreateNamedRelationshipMethods.new
-        @test_object2.pid = increment_pid 
-        @test_object2.should respond_to(:testing_append)
-        @test_object2.should respond_to(:testing_remove)
-        #test execution in base_spec since method definitions include methods in ActiveFedora::Base
-      end
-    end
-
-    describe '#create_bidirectional_named_relationship_methods' do
-      class MockCreateNamedRelationshipMethods < SpecNode2
-        register_named_relationship :self, "testing_outbound", :is_part_of, :type=>SpecNode2
-        create_bidirectional_named_relationship_methods "testing", "testing_outbound"
-      end
-      
-      it 'should create an append and remove method for each outbound relationship' do
-        @test_object2 = MockCreateNamedRelationshipMethods.new
-        @test_object2.pid = increment_pid 
-        @test_object2.should respond_to(:testing_append)
-        @test_object2.should respond_to(:testing_remove)
-        #test execution in base_spec since method definitions include methods in ActiveFedora::Base
-      end
-    end
-    
-    describe '#def named_predicate_exists_with_different_name?' do
-      
-      it 'should return true if a predicate exists for same subject and different name but not different subject' do
-        class MockPredicateExists < SpecNode2
-          has_relationship "testing", :has_part, :type=>SpecNode2
-          has_relationship "testing2", :has_member, :type=>SpecNode2
-          has_relationship "testing_inbound", :is_part_of, :type=>SpecNode2, :inbound=>true
-      
-          named_predicate_exists_with_different_name?(:self,"testing",:has_part).should == false
-          named_predicate_exists_with_different_name?(:self,"testing3",:has_part).should == true
-          named_predicate_exists_with_different_name?(:inbound,"testing",:has_part).should == false
-          named_predicate_exists_with_different_name?(:self,"testing2",:has_member).should == false
-          named_predicate_exists_with_different_name?(:self,"testing3",:has_member).should == true
-          named_predicate_exists_with_different_name?(:inbound,"testing2",:has_member).should == false
-          named_predicate_exists_with_different_name?(:self,"testing_inbound",:is_part_of).should == false
-          named_predicate_exists_with_different_name?(:inbound,"testing_inbound",:is_part_of).should == false
-          named_predicate_exists_with_different_name?(:inbound,"testing_inbound2",:is_part_of).should == true
-        end
-      end
-    end
-  end
 end