active-fedora 1.1.13 → 1.2.0

data/spec/unit/base_spec.rb

@@ -19,10 +19,16 @@ class FooHistory < ActiveFedora::Base
   end 
 end
 
+@@last_pid = 0  
+
 describe ActiveFedora::Base do
+  
+  def increment_pid
+    @@last_pid += 1    
+  end
 
   before(:each) do
-    Fedora::Repository.instance.stubs(:nextid).returns("_nextid_")
+    Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
     @test_object = ActiveFedora::Base.new
     @test_object.new_object = true
   end
@@ -141,6 +147,7 @@ describe ActiveFedora::Base do
       mock_relationship = mock("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.add_relationship("predicate", "object")
     end
@@ -149,6 +156,7 @@ describe ActiveFedora::Base 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")]
@@ -156,7 +164,42 @@ describe ActiveFedora::Base do
         @test_object.add_relationship(rel.predicate, rel.object)
       end
     end
-
+    
+    it 'should add a relationship to an object only if it does not exist already' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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]}}
+      #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]}}
+    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
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object3 = ActiveFedora::Base.new
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @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.remove_relationship(:has_part,@test_object3)
+      #check only one item removed
+      @test_object.relationships.should == {:self=>{:has_part=>[r2.object]}}
+      @test_object.remove_relationship(:has_part,@test_object4)
+      #check last item removed and predicate removed since now emtpy
+      @test_object.relationships.should == {:self=>{}}
+    end
   end
 
   it 'should provide #relationships' do
@@ -279,7 +322,7 @@ describe ActiveFedora::Base do
       solr_doc = @test_object.to_solr
       solr_doc[:system_create_dt].should eql("cDate")
       solr_doc[:system_modified_dt].should eql("mDate")
-      solr_doc[:id].should eql(@test_object.pid)
+      solr_doc[:id].should eql("#{@test_object.pid}")
     end
 
     it "should add self.class as the :active_fedora_model" do
@@ -319,7 +362,7 @@ describe ActiveFedora::Base do
       solr_doc = @test_object.to_solr
       solr_doc[:system_create_dt].should eql("cDate")
       solr_doc[:system_modified_dt].should eql("mDate")
-      solr_doc[:id].should eql(@test_object.pid)
+      solr_doc[:id].should eql("#{@test_object.pid}")
     end
 
     it "should omit base metadata and RELS-EXT if :model_only==true" do
@@ -345,7 +388,7 @@ describe ActiveFedora::Base do
       solr_doc = @test_object.to_solr
       solr_doc[:system_create_dt].should eql(cdate)
       solr_doc[:system_modified_dt].should eql(mdate)
-      solr_doc[:id].should eql(@test_object.pid)
+      solr_doc[:id].should eql("#{@test_object.pid}")
       solr_doc[:active_fedora_model_s].should eql(@test_object.class.inspect)
       
       ActiveFedora::SolrService.load_mappings(File.join(File.dirname(__FILE__), "..", "..", "config", "solr_mappings_af_0.1.yml"))
@@ -355,7 +398,7 @@ describe ActiveFedora::Base do
       end
       solr_doc[:system_create_date].should eql(cdate)
       solr_doc[:system_modified_date].should eql(mdate)
-      solr_doc[:id].should eql(@test_object.pid)
+      solr_doc[:id].should eql("#{@test_object.pid}")
       solr_doc[:active_fedora_model_field].should eql(@test_object.class.inspect)
     end
     
@@ -557,6 +600,54 @@ describe ActiveFedora::Base do
     FooHistory.solr_search("pid: foobar", {:ding=>:dang}).should == {:baz=>:bif}
   end
 
+  it 'should provide #named_relationships' do
+    @test_object.should respond_to(:named_relationships)
+  end
+  
+  describe '#named_relationships' do
+    
+    class MockNamedRelationships < ActiveFedora::Base
+      has_relationship "testing", :has_part, :type=>ActiveFedora::Base
+      has_relationship "testing2", :has_member, :type=>ActiveFedora::Base
+      has_relationship "testing_inbound", :has_part, :type=>ActiveFedora::Base, :inbound=>true
+    end
+    
+    it 'should return current named relationships' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockNamedRelationships.new
+      @test_object2.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(MockNamedRelationships))
+      @test_object.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(ActiveFedora::Base))
+      #should return expected named relationships
+      @test_object2.named_relationships
+      @test_object2.named_relationships.should == {:self=>{"testing"=>[],"testing2"=>[]}}
+      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:dummy,:object=>@test_object})
+      @test_object2.add_named_relationship("testing",@test_object)
+      @test_object2.named_relationships.should == {:self=>{"testing"=>[r.object],"testing2"=>[]}}
+    end 
+  end
 
-
+  
+  describe '#create_named_relationship_methods' do
+    class MockCreateNamedRelationshipMethodsBase < ActiveFedora::Base
+      register_named_relationship :self, "testing", :is_part_of, :type=>ActiveFedora::Base
+      create_named_relationship_methods "testing"
+    end
+      
+    it 'should append and remove using helper methods for each outbound relationship' do
+      Fedora::Repository.instance.stubs(:nextid).returns(increment_pid)
+      @test_object2 = MockCreateNamedRelationshipMethodsBase.new 
+      @test_object2.should respond_to(:testing_append)
+      @test_object2.should respond_to(:testing_remove)
+      #test executing each one to make sure code added is correct
+      r = ActiveFedora::Relationship.new({:subject=>:self,:predicate=>:has_model,:object=>ActiveFedora::ContentModel.pid_from_ruby_class(ActiveFedora::Base)})
+      @test_object.add_relationship(r.predicate,r.object)
+      @test_object2.add_relationship(r.predicate,r.object)
+      @test_object2.testing_append(@test_object)
+      #create relationship to access generate_uri method for an object
+      r = ActiveFedora::Relationship.new(:subject=>:self, :predicate=>:dummy, :object=>@test_object)
+      @test_object2.named_relationships.should == {:self=>{"testing"=>[r.object]}}
+      @test_object2.testing_remove(@test_object)
+      @test_object2.named_relationships.should == {:self=>{"testing"=>[]}}
+    end
+  end
 end

data/spec/unit/nokogiri_datastream_spec.rb

@@ -20,6 +20,10 @@ describe ActiveFedora::NokogiriDatastream do
   after(:each) do
   end
   
+  it "should include the Solrizer::XML::TerminologyBasedSolrizer for .to_solr support" do
+    ActiveFedora::NokogiriDatastream.included_modules.should include(Solrizer::XML::TerminologyBasedSolrizer)
+  end
+  
   describe '#new' do
     it 'should provide #new' do
       ActiveFedora::NokogiriDatastream.should respond_to(:new)
@@ -59,7 +63,7 @@ describe ActiveFedora::NokogiriDatastream do
       # In other words, { "fubar"=>"dork" } should have the same effect as { "fubar"=>{"0"=>"dork"} }
       result = @mods_ds.update_indexed_attributes( { [{":person"=>"0"}, "role"]=>"the role" } )
       result.should == {"person_0_role"=>{"0"=>"the role"}}
-      @mods_ds.property_values('//oxns:name[@type="personal"][1]/oxns:role').first.should == "the role"
+      @mods_ds.term_values('//oxns:name[@type="personal"][1]/oxns:role').first.should == "the role"
     end
     it "should do nothing if field key is a string (must be an array or symbol).  Will not accept xpath queries!" do
       xml_before = @mods_ds.to_xml
@@ -119,24 +123,36 @@ describe ActiveFedora::NokogiriDatastream do
     # end
     # 
     # it "should allow deleting of values and should delete values so that to_xml does not return emtpy nodes" do
-    #   att= {"fubar"=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}}
-    #   @test_ds.update_indexed_attributes(att)
-    #   @test_ds.fubar_values.should == ['mork', 'york', 'mangle']
+    #   att= {[{"person"=>"0"},"description"]=>{"-1"=>"mork", "0"=>"york", "1"=>"mangle"}} 
+    #   @mods_ds.update_indexed_attributes(att)
+    #   @mods_ds.fubar_values.should == ['mork', 'york', 'mangle']
     #   rexml = REXML::Document.new(@test_ds.to_xml)
     #   #puts rexml.root.elements.each {|el| el.to_s}
     #   #puts rexml.root.elements.to_a.inspect
     #   rexml.root.elements.to_a.length.should == 3
-    #   @test_ds.update_indexed_attributes({"fubar"=>{"1"=>""}})
-    #   @test_ds.fubar_values.should == ['mork', 'mangle']
+    #   @mods_ds.update_indexed_attributes({[{"person"=>"0"},"description"]=>{"1"=>""}})
+    #   @mods_ds.fubar_values.should == ['mork', 'mangle']
     #   rexml = REXML::Document.new(@test_ds.to_xml)
     #   rexml.root.elements.to_a.length.should == 2
-    #   @test_ds.update_indexed_attributes({"fubar"=>{"0"=>:delete}})
-    #   @test_ds.fubar_values.should == ['mangle']
+    #   @mods_ds.update_indexed_attributes({[{"person"=>"0"},"description"]=>{"0"=>:delete}})
+    #   @mods_ds.fubar_values.should == ['mangle']
     #   rexml = REXML::Document.new(@test_ds.to_xml)
     #   rexml.root.elements.to_a.length.should == 1
-    #   
+    # end
+    it "should allow deleting of values and should delete values so that to_xml does not return emtpy nodes" do
+      att= {[{"person"=>"0"},"description"]=>{"0"=>"york", "1"=>"mangle","2"=>"mork"}}
+      @mods_ds.update_indexed_attributes(att)
+      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['york', 'mangle', 'mork']
+      
+      @mods_ds.update_indexed_attributes({[{"person"=>"0"},"description"]=>{"1"=>""}})
+      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['york', 'mork']
+      
+      @mods_ds.update_indexed_attributes({[{"person"=>"0"},"description"]=>{"0"=>:delete}})
+      @mods_ds.get_values([{"person"=>"0"},"description"]).should == ['mork']
+    end
+    # it "should delete values so that to_xml does not return emtpy nodes" do
     #   @test_ds.fubar_values = ["val1", nil, "val2"]
-    #   @test_ds.update_indexed_attributes({"fubar"=>{"1"=>""}})
+    #   @test_ds.update_indexed_attributes({{[{"person"=>"0"},"description"]=>{"1"=>""}})
     #   @test_ds.fubar_values.should == ["val1", "val2"]
     # end
     
@@ -154,12 +170,12 @@ describe ActiveFedora::NokogiriDatastream do
     end
     
     it "should call lookup with field_name and return the text values from each resulting node" do
-      @mods_ds.expects(:property_values).with("--my xpath--").returns(["value1", "value2"])
+      @mods_ds.expects(:term_values).with("--my xpath--").returns(["value1", "value2"])
       @mods_ds.get_values("--my xpath--").should == ["value1", "value2"]
     end
-    it "should assume that field_name that are strings are xpath queries" do
+    it "should assume that field_names that are strings are xpath queries" do
       ActiveFedora::NokogiriDatastream.expects(:accessor_xpath).never
-      @mods_ds.expects(:property_values).with("--my xpath--").returns(["abstract1", "abstract2"])
+      @mods_ds.expects(:term_values).with("--my xpath--").returns(["abstract1", "abstract2"])
       @mods_ds.get_values("--my xpath--").should == ["abstract1", "abstract2"]
     end
     it "should assume field_names that are symbols or arrays are pointers to accessors declared in this datastreams model" do
@@ -263,136 +279,4 @@ describe ActiveFedora::NokogiriDatastream do
     end
   end
   
-  
-  describe ".to_solr" do
-    
-    after(:all) do
-      # Revert to default mappings after running tests
-      ActiveFedora::SolrService.load_mappings
-    end
-    
-    it "should iterate through the class accessors, calling .solrize_accessor on each and passing in the solr doc" do
-      mock_accessors = {:accessor1=>:accessor1_info, :accessor2=>:accessor2_info}
-      ActiveFedora::NokogiriDatastream.stubs(:accessors).returns(mock_accessors)
-      doc = Solr::Document.new
-      mock_accessors.each_pair do |k,v|
-        @test_ds.expects(:solrize_accessor).with(k, v, :solr_doc=>doc)
-      end
-      @test_ds.to_solr(doc)
-    end
-    
-    it "should provide .to_solr and return a SolrDocument" do
-      @test_ds.should respond_to(:to_solr)
-      @test_ds.to_solr.should be_kind_of(Solr::Document)
-    end
-    
-    it "should optionally allow you to provide the Solr::Document to add fields to and return that document when done" do
-      doc = Solr::Document.new
-      @test_ds.to_solr(doc).should equal(doc)
-    end
-    
-  end
-  
-  describe ".solrize_accessor" do
-    before(:all) do
-      class AccessorizedDs < ActiveFedora::NokogiriDatastream
-        
-        root_property :mods, "mods", "http://www.loc.gov/mods/v3", :attributes=>["id", "version"], :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd"          
-        
-        accessor :title_info, :relative_xpath=>'oxns:titleInfo', :children=>[
-          {:main_title=>{:relative_xpath=>'oxns:title'}},         
-          {:language =>{:relative_xpath=>{:attribute=>"lang"} }}
-          ]
-        accessor :finnish_title_info, :relative_xpath=>'oxns:titleInfo[@lang="finnish"]', :children=>[
-          {:main_title=>{:relative_xpath=>'oxns:title'}},         
-          {:language =>{:relative_xpath=>{:attribute=>"lang"} }}
-          ] 
-        accessor :abstract
-        accessor :topic_tag, :relative_xpath=>'oxns:subject/oxns:topic'
-        accessor :person, :relative_xpath=>'oxns:name[@type="personal"]',  :children=>[
-          {:last_name=>{:relative_xpath=>'oxns:namePart[@type="family"]'}}, 
-          {:first_name=>{:relative_xpath=>'oxns:namePart[@type="given"]'}}, 
-          {:institution=>{:relative_xpath=>'oxns:affiliation'}}, 
-          {:role=>{:children=>[
-            {:text=>{:relative_xpath=>'oxns:roleTerm[@type="text"]'}},
-            {:code=>{:relative_xpath=>'oxns:roleTerm[@type="code"]'}}
-          ]}}
-        ]
-      end
-    end
-    
-    before(:each) do
-      file = fixture(File.join("mods_articles", "hydrangea_article1.xml"))
-      @accessorized_ds = AccessorizedDs.new(:blob=>file)
-    end
-    
-    it "should perform a lookup and iterate over nodes in the result set calling solrize_node then calling solrize_accessor on any of the children, adding accessor_name & node index to parents array" do
-      mock_title_info_set = ["TI1", "TI2"]
-      mock_main_title_set = ["main title"]
-      mock_language_set = ["language"]
-      
-      solr_doc = Solr::Document.new
-      
-      AccessorizedDs.expects(:accessor_xpath).with( :title_info ).returns("title_info_xpath")
-      @accessorized_ds.expects(:lookup).with( "title_info_xpath" ).returns(mock_title_info_set)
-      
-      mock_title_info_set.each do |tin| 
-        node_index = mock_title_info_set.index(tin)
-        @accessorized_ds.expects(:solrize_node).with(tin, [:title_info], solr_doc) 
-        
-        # Couldn't mock the recursive calls to solrize_accessor without preventing the initial one, so was forced to mock out the whole recursive stack.
-        # @accessorized_ds.expects(:solrize_accessor).with(:main_title, AccessorizedDs.accessors[:title_info][:children][:main_title], :parents=>[{:title_info=>node_index}])      
-        # @accessorized_ds.expects(:solrize_accessor).with(:language, AccessorizedDs.accessors[:title_info][:children][:language], :parents=>[{:title_info=>node_index}])
-          AccessorizedDs.expects(:accessor_xpath).with( {:title_info=>node_index}, :main_title ).returns("title_info_main_title_xpath")
-          AccessorizedDs.expects(:accessor_xpath).with( {:title_info=>node_index}, :language ).returns("title_info_language_xpath")
-          @accessorized_ds.expects(:lookup).with( "title_info_main_title_xpath" ).returns(mock_main_title_set)
-          @accessorized_ds.expects(:lookup).with( "title_info_language_xpath" ).returns(mock_language_set)
-          @accessorized_ds.expects(:solrize_node).with("main title", [{:title_info=>node_index}, :main_title], solr_doc) 
-          @accessorized_ds.expects(:solrize_node).with("language", [{:title_info=>node_index}, :language], solr_doc) 
-      end
-      
-      @accessorized_ds.solrize_accessor(:title_info, AccessorizedDs.accessors[:title_info], :solr_doc=>solr_doc)
-      
-    end
-    
-    it "should not call solrize_accessor once it reaches an accessor with no children accessors set" do
-      pending "not sure how to test for this"
-      @accessorized_ds.solrize_accessor(:text, AccessorizedDs.accessor_info( [{:person=>1}, :last_name] ), :parents=>[{:person=>1}])
-    end
-    
-    it "should use values form parents array when requesting accessor_xpath and when generating solr field names" do
-      parents_array = [{:person=>0}, {:role=>1}]
-      AccessorizedDs.accessors[:person][:children][:role][:children][:text]
-      
-      # This should catch the "submitter" roleTerm from the second role node within the first person node and put it into a solr field called "person_0_role_2_text_0_t" and a solr field called "person_role_text_t"
-      @accessorized_ds.solrize_accessor(:text, AccessorizedDs.accessor_info( *parents_array + [:text] ), :parents=>parents_array)
-    end
-    
-    it "should use Solr mappings to generate field names" do
-
-      solr_doc =  @accessorized_ds.to_solr
-      #should have these
-      
-      solr_doc[:abstract_t].should == "ABSTRACT"
-      solr_doc[:title_info_1_language_t].should == "finnish"
-      solr_doc[:person_1_role_0_text_t].should == "teacher"
-      solr_doc[:finnish_title_info_language_t].should == "finnish"
-      solr_doc[:finnish_title_info_main_title_t].should == "Artikkelin otsikko Hydrangea artiklan 1"
-
-      # solr_doc[:mydate_date].should == "fake-date"
-      # 
-      # solr_doc[:publisher_t].should be_nil
-      # solr_doc[:coverage_t].should be_nil
-      # solr_doc[:creation_date_dt].should be_nil
-      # solr_doc.should == ""
-      
-    end
-  end
-  
-  describe ".solrize_node" do
-    it "should create a solr field containing node.text"
-    it "should create hierarchical field entries if parents is not empty"
-    it "should only create one node if parents is empty"
-  end
-  
 end

data/spec/unit/semantic_node_spec.rb

@@ -7,8 +7,20 @@ require 'xmlsimple'
 #include ActiveFedora::SemanticNode
 #include Mocha::Standalone
 
+@@last_pid = 0
+
+class SpecNode2
+  include ActiveFedora::SemanticNode
+  
+  attr_accessor :pid
+end
+
 describe ActiveFedora::SemanticNode do
   
+  def increment_pid
+    @@last_pid += 1    
+  end
+    
   before(:all) do
     @pid = "test:sample_pid"
     @uri = "info:fedora/#{@pid}"
@@ -18,10 +30,16 @@ describe ActiveFedora::SemanticNode do
   end
   
   before(:each) do
-    class SpecNode 
+    class SpecNode
       include ActiveFedora::SemanticNode
+      
+      attr_accessor :pid
     end
+    
     @node = SpecNode.new
+    @node.pid = increment_pid
+    @test_object = SpecNode2.new
+    @test_object.pid = increment_pid    
     @stub_relationship = stub("mock_relationship", :subject => @pid, :predicate => "isMemberOf", :object => "demo:8", :class => ActiveFedora::Relationship)  
     @test_relationship = ActiveFedora::Relationship.new(:subject => @pid, :predicate => "isMemberOf", :object => "demo:9")  
     @test_relationship1 = ActiveFedora::Relationship.new(:subject => :self, :predicate => :is_member_of, :object => "demo:10")  
@@ -31,6 +49,26 @@ describe ActiveFedora::SemanticNode do
   
   after(:each) do
     Object.send(:remove_const, :SpecNode)
+    begin
+    @test_object.delete
+    rescue
+    end
+    begin
+    @test_object2.delete
+    rescue
+    end
+    begin
+    @test_object3.delete
+    rescue
+    end
+    begin
+    @test_object4.delete
+    rescue
+    end
+    begin
+    @test_object5.delete
+    rescue
+    end
   end
   
   it 'should provide predicate mappings for entire Fedora Relationship Ontology' do
@@ -118,6 +156,64 @@ describe ActiveFedora::SemanticNode do
       containers_result.should include("container:B")
     end
     
+    class MockHasRelationship < 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
+      
+    #can only duplicate predicates if not both inbound or not both outbound
+    class MockHasRelationshipDuplicatePredicate < SpecNode2
+      has_relationship "testing", :has_member, :type=>SpecNode2
+      had_exception = false
+      begin
+        has_relationship "testing2", :has_member, :type=>SpecNode2
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception if duplicate predicate used" unless had_exception 
+    end
+      
+    #can only duplicate predicates if not both inbound or not both outbound
+    class MockHasRelationshipDuplicatePredicate2 < SpecNode2
+      has_relationship "testing", :has_member, :type=>SpecNode2, :inbound=>true
+      had_exception = false
+      begin
+        has_relationship "testing2", :has_member, :type=>SpecNode2, :inbound=>true
+      rescue
+        had_exception = true
+      end
+      raise "Did not raise exception if duplicate predicate used" unless had_exception 
+    end
+      
+    it 'should create relationship descriptions both inbound and outbound' 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.should respond_to(:testing_append)
+      @test_object2.should respond_to(:testing_remove)
+      @test_object2.should respond_to(:testing2_append)
+      @test_object2.should respond_to(:testing2_remove)
+      #make sure append/remove method not created for inbound rel
+      @test_object2.should_not respond_to(:testing_inbound_append)
+      @test_object2.should_not respond_to(:testing_inbound_remove)
+      
+      @test_object2.named_relationships_desc.should == 
+      {:inbound=>{"testing_inbound"=>{:type=>SpecNode2, 
+                                     :predicate=>:has_part, 
+                                      :inbound=>true, 
+                                      :singular=>nil}}, 
+       :self=>{"testing"=>{:type=>SpecNode2, 
+                           :predicate=>:has_part, 
+                           :inbound=>false, 
+                           :singular=>nil},
+               "testing2"=>{:type=>SpecNode2, 
+                            :predicate=>:has_member, 
+                            :inbound=>false, 
+                            :singular=>nil}}}
+    end
   end
     
   describe '#create_inbound_relationship_finders' do
@@ -134,6 +230,7 @@ describe ActiveFedora::SemanticNode do
       SpecNode.create_inbound_relationship_finders("containers", :is_member_of, :inbound => true)  
       local_node.should respond_to(:containers_ids)
       local_node.should respond_to(:containers)
+      local_node.should respond_to(:containers_from_solr)
     end
     
     it "resulting finder should search against solr and use Model#load_instance to build an array of objects" do
@@ -195,7 +292,8 @@ describe ActiveFedora::SemanticNode do
       local_node.should_not respond_to(:containers)
       SpecNode.create_outbound_relationship_finders("containers", :is_member_of)  
       local_node.should respond_to(:containers_ids)
-      local_node.should respond_to(:containers)      
+      local_node.should respond_to(:containers)  
+      local_node.should respond_to(:containers_from_solr)  
     end
     
     describe " resulting finder" do
@@ -348,4 +446,383 @@ describe ActiveFedora::SemanticNode 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)
+      #check both are there
+      @test_object.relationships.should == {:self=>{:has_part=>[r.object,r2.object]}}
+      @test_object.remove_relationship(r)
+      #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
+      #check only one item removed
+      @test_object.relationships.should == {:self=>{:has_part=>[r2.object]}}
+      @test_object.remove_relationship(r2)
+      #check last item removed and predicate removed since now emtpy
+      @test_object.relationships.should == {:self=>{}}
+      
+    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?)
+  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
+    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
+      begin
+        @test_object.assert_kind_of 'SpecNode2', @test_object, ActiveFedora::Base
+      rescue
+        had_exception = true
+      end
+      raise "Failed to throw exception with kind of mismatch" unless had_exception
+      #now should not throw any exception
+      @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 '#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