active-fedora 1.0.5 → 1.1.0

data/spec/unit/rels_ext_datastream_spec.rb

@@ -0,0 +1,99 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require "rexml/document"
+require 'ftools'
+
+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")  
+  
+    @sample_xml = REXML::Document.new(@sample_xml_string)
+  end
+  
+  before(:each) do
+      @test_ds = ActiveFedora::RelsExtDatastream.new(:pid => @pid)
+  end
+  
+  it "should respond to #new" do  
+    ActiveFedora::RelsExtDatastream.should respond_to(:new)
+  end
+  
+  describe "#new" do
+    it "should create a datsatream with DSID of RELS-EXT" do
+      test_datastream = ActiveFedora::RelsExtDatastream.new
+      test_datastream.dsid.should eql("RELS-EXT")  
+    end
+  end
+  
+  it 'should respond to #save' do
+    @test_ds.should respond_to(:save)
+  end
+  
+  describe '#save' do
+    
+    it "should call super.save" do
+      # Funny jiggering to mock super when RelsExt datstream calls super.save
+      Fedora::Repository.instance.expects(:save).returns(mock("boo"))
+      @test_ds.save
+    end
+    
+    it "should generate new rdf/xml as the datastream content if the object has been changed" do
+      @test_ds.dirty = true
+      @test_ds.expects(:to_rels_ext)
+      @test_ds.expects(:content=)
+      # Funny jiggering to mock super when RelsExt datstream calls super.save
+      Fedora::Repository.instance.expects(:save).returns(mock("boo"))
+      @test_ds.save
+    end
+  
+  end
+  
+  describe "#from_xml" do
+    before(:all) do
+      ActiveFedora::SolrService.register
+      @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.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"]}}
+      doc = REXML::Document.new(@test_obj.inner_object.object_xml)
+      el = doc.elements["/foxml:digitalObject//foxml:datastream[@ID='RELS-EXT']"]
+      new_ds = ActiveFedora::RelsExtDatastream.new
+      new_ds.relationships.should == {:self=>{}}
+      ActiveFedora::RelsExtDatastream.from_xml(new_ds,el)
+      new_ds.relationships.should == @test_obj.relationships
+    end
+  end
+  
+  
+  describe ".to_solr" do
+    
+    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 serialize the relationships into a Solr::Document" do
+      @test_ds.add_relationship(@test_relationship1)
+      @test_ds.add_relationship(@test_relationship2)
+      @test_ds.add_relationship(@test_relationship3)
+      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"
+      solr_doc[:has_part_s].should == "info:fedora/demo:12"
+    end
+  end
+  
+  it "should treat :self and self.pid as equivalent subjects"
+  
+end

data/spec/unit/repository_spec.rb

@@ -0,0 +1,136 @@
+require File.join( File.dirname(__FILE__),  "../spec_helper" )
+
+describe Fedora::Repository do
+  
+  after(:all) do
+    Fedora::Repository.register(ActiveFedora.fedora_config[:url])
+  end
+  
+  it "should trim extra slash on uri" do
+    Fedora::Repository.expects(:new).with('http://bar.baz/bat', nil)
+    Fedora::Repository.register('http://bar.baz/bat/')
+    Fedora::Repository.expects(:new).with('http://bar.baz/bat', nil)
+    Fedora::Repository.register(URI.parse('http://bar.baz/bat/'))
+  end
+
+  it "should accept a url to register" do 
+    Fedora::Repository.expects(:new).with('http://bar.baz', nil).returns(stub_everything)
+    Fedora::Repository.register('http://bar.baz').should_not be_nil
+    z = Fedora::Repository.instance
+    z.should_not be_nil
+    (z === Fedora::Repository.instance).should == true
+  end
+  
+  it "should initialize a repo" do 
+    Fedora::Repository.expects(:new).with('http://foo.bar', nil).returns(stub_everything)
+    Fedora::Repository.register('http://foo.bar')
+    z = Fedora::Repository.instance
+    y = Fedora::Repository.instance
+    z.should_not be_nil
+    y.should_not be_nil
+    (z===y).should == true
+  end
+
+  it 'should be a singleton' do
+    Fedora::Repository.expects(:new).with('http://foo.bar',nil).returns(stub_everything)
+    Fedora::Repository.register('http://foo.bar')
+    a = Fedora::Repository.instance
+    b = Fedora::Repository.instance
+    (a === b).should == true
+  end
+
+  it "should be able to reserve an id" do
+    bodymock = mock('body')
+    bodymock.expects(:body).returns <<-EOS
+    <?xml version="1.0" encoding="UTF-8"?>
+   <pidList xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.fedora.info/definitions/1/0/management/ http://www.fedora.info/definitions/1/0/objectHistory.xsd">
+     <pid>changeme:5035</pid>
+     </pidList>
+    EOS
+
+    Fedora::Repository.register('http://fedoraAdmin:fedoraAdmin@127.0.0.1:8080/fedora').should_not be_nil
+    Fedora::Repository.instance.send(:connection).expects(:post).with('/fedora/management/getNextPID?xml=true').returns(bodymock)
+    Fedora::Repository.instance.should_not be_nil
+    Fedora::Repository.instance.nextid.should == 'changeme:5035'
+  end
+  
+  it "should have attributes corresponding to the info in fedora/describe" do
+    Fedora::Repository.register('http://foo.bar')
+    #skipping oai_namespace_identifier and oai_delimiter
+    %w[repository_name base_url fedora_version pid_namespace pid_delimiter].each do |attribute_name|
+      Fedora::Repository.instance.should respond_to(attribute_name)
+      Fedora::Repository.instance.should respond_to(attribute_name + "=")
+    end
+  end
+  
+  describe "export" do
+    it "should call fetch_custom with the appropriate parameters" do
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:FOXML-1.1", :context=>"archive")
+      Fedora::Repository.instance.export("test:my_pid")
+    end
+    it "should support :foxml, :mets, :atom, and :atom_zip" do
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOM-1.1", :context=>"archive")
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOMZip-1.1", :context=>"archive")
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:FOXML-1.1", :context=>"archive")
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:METSFedoraExt-1.1", :context=>"archive")
+      
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom)
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom_zip)
+      Fedora::Repository.instance.export("test:my_pid", :format=>:foxml)
+      Fedora::Repository.instance.export("test:my_pid", :format=>:mets)
+    end
+    it "should allow you to pass through the format uri as a string" do
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOMZip-1.1", :context=>"archive")
+      Fedora::Repository.instance.export("test:my_pid", :format=>"info:fedora/fedora-system:ATOMZip-1.1") 
+    end
+    it "should support export context" do
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOM-1.1", :context=>"public").times(2)
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOM-1.1", :context=>"migrate")
+      Fedora::Repository.instance.expects(:fetch_custom).with("test:my_pid", "export", :format=>"info:fedora/fedora-system:ATOM-1.1", :context=>"archive")
+
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom, :context=>:public)
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom, :context=>"public")
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom, :context=>:migrate)
+      Fedora::Repository.instance.export("test:my_pid", :format=>:atom, :context=>:archive)
+    end
+  end
+    
+  describe "ingest" do
+    it "should post the provided xml or file to fedora" do
+      foxml = fixture("test_12.foxml.xml").read
+      connection = Fedora::Repository.instance.send(:connection)
+      connection.expects(:post).with("/fedora/objects/new",foxml)
+      Fedora::Repository.instance.ingest(foxml)
+    end
+    it "should accept a file as its input" do
+      foxml_file = fixture("test_12.foxml.xml")
+      foxml = fixture("test_12.foxml.xml").read
+      connection = Fedora::Repository.instance.send(:connection)
+      connection.expects(:post).with("/fedora/objects/new",foxml)
+      Fedora::Repository.instance.ingest(foxml_file)
+    end
+  end
+  
+  describe "#register" do
+    after(:all) do
+      Fedora::Repository.register(ActiveFedora.fedora_config[:url])
+    end
+    it "should initialize the attributes from fedora/describe" do
+      sample_attrs = {"sampleSearch-URL"=>["http://127.0.0.1:8080/fedora/search"], "repositoryOAI-identifier"=>[{"OAI-sample"=>["oai:example.org:changeme:100"], "OAI-delimiter"=>[":"], "OAI-namespaceIdentifier"=>["example.org"]}], "repositoryBaseURL"=>["http://127.0.0.1:8080/fedora"], "xsi:schemaLocation"=>"http://www.fedora.info/definitions/1/0/access/ http://www.fedora.info/definitions/1/0/fedoraRepository.xsd", "xmlns:xsd"=>"http://www.w3.org/2001/XMLSchema", "repositoryPID"=>[{"PID-sample"=>["changeme:100"], "PID-namespaceIdentifier"=>["changeme"], "PID-delimiter"=>[":"], "retainPID"=>["*"]}], "adminEmail"=>["bob@example.org", "sally@example.org"], "repositoryVersion"=>["3.1"], "sampleOAI-URL"=>["http://localhost:8080/fedora/oai?verb=Identify"], "sampleAccess-URL"=>["http://localhost:8080/fedora/get/demo:5"], "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "repositoryName"=>["Fedora Repository"]}
+      Fedora::Repository.any_instance.expects(:describe_repository).returns(sample_attrs)
+      Fedora::Repository.register('http://foo.bar')
+      boo = Fedora::Repository.instance
+      boo.repository_name.should == "Fedora Repository"
+      boo.base_url.should ==  "http://127.0.0.1:8080/fedora"
+      boo.fedora_version.should ==  "3.1"
+      boo.pid_namespace.should ==  "changeme"
+      boo.pid_delimiter.should == ":"
+    end
+  end
+  
+  
+  it "should provide .describe_repository" do
+    Fedora::Repository.instance.should respond_to(:describe_repository)
+  end
+
+end

data/spec/unit/rf_datastream_spec.rb

@@ -0,0 +1,49 @@
+require File.join( File.dirname(__FILE__),  "../spec_helper" )
+
+require 'ruby-fedora'
+
+
+describe Fedora::Datastream do
+  
+  before(:each) do
+    Fedora::Repository.register(ActiveFedora.fedora_config[:url])
+    @test_datastream = Fedora::Datastream.new
+  end
+  
+  it "should track the controlgroup attr" do
+    td = Fedora::Datastream.new(:controlGroup=>'M')
+    td.control_group.should == 'M'
+  end
+  
+  it "should provide .url" do
+    @test_datastream.should respond_to(:url)
+    @test_datastream.expects(:pid).returns("_foo_")
+    @test_datastream.url.should == 'http://localhost:8080/fedora/objects/_foo_/datastreams/'
+  end
+  
+  describe ".url" do
+    it "should return the Repository base_url with /objects/pid appended" do
+      Fedora::Repository.instance.expects(:base_url).returns("BASE_URL")
+      @test_datastream.expects(:pid).returns("_PID_")
+      @test_datastream.expects(:dsid).returns("_DSID_")
+      @test_datastream.url.should == "BASE_URL/objects/_PID_/datastreams/_DSID_"
+    end
+  end
+  
+  describe ".label" do
+    it "should return the dsLabel attribute" do
+      @test_datastream.label.should == @test_datastream.attributes[:dsLabel]
+    end
+  end
+  
+  describe ".label=" do
+    it "should set the dsLabel attribute" do
+      @test_datastream.label.should_not == "Foo dsLabel"
+      @test_datastream.attributes[:dsLabel].should_not == "Foo dsLabel"
+      @test_datastream.label = "Foo dsLabel"
+      @test_datastream.label.should == "Foo dsLabel"
+      @test_datastream.attributes[:dsLabel].should == "Foo dsLabel"
+    end
+  end
+
+end

data/spec/unit/semantic_node_spec.rb

@@ -0,0 +1,354 @@
+require File.join( File.dirname(__FILE__), "../spec_helper" )
+
+require 'active_fedora'
+require 'xmlsimple'
+#require 'mocha'
+
+#include ActiveFedora::SemanticNode
+#include Mocha::Standalone
+
+describe ActiveFedora::SemanticNode do
+  
+  before(:all) do
+    @pid = "test:sample_pid"
+    @uri = "info:fedora/#{@pid}"
+    @sample_solr_hits = [{"id"=>"_PID1_", "active_fedora_model_s"=>["AudioRecord"]},
+                          {"id"=>"_PID2_", "active_fedora_model_s"=>["AudioRecord"]},
+                          {"id"=>"_PID3_", "active_fedora_model_s"=>["AudioRecord"]}]
+  end
+  
+  before(:each) do
+    class SpecNode 
+      include ActiveFedora::SemanticNode
+    end
+    @node = SpecNode.new
+    @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")  
+    @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")
+  end
+  
+  after(:each) do
+    Object.send(:remove_const, :SpecNode)
+  end
+  
+  it 'should provide predicate mappings for entire Fedora Relationship Ontology' do
+    desired_mappings = Hash[:is_member_of => "isMemberOf",
+                          :has_member => "hasMember",
+                          :is_part_of => "isPartOf",
+                          :has_part => "hasPart",
+                          :is_member_of_collection => "isMemberOfCollection",
+                          :has_collection_member => "hasCollectionMember",
+                          :is_constituent_of => "isConstituentOf",
+                          :has_constituent => "hasConstituent",
+                          :is_subset_of => "isSubsetOf",
+                          :has_subset => "hasSubset",
+                          :is_derivation_of => "isDerivationOf",
+                          :has_derivation => "hasDerivation",
+                          :is_dependent_of => "isDependentOf",
+                          :has_dependent => "hasDependent",
+                          :is_description_of => "isDescriptionOf",
+                          :has_description => "hasDescription",
+                          :is_metadata_for => "isMetadataFor",
+                          :has_metadata => "hasMetadata",
+                          :is_annotation_of => "isAnnotationOf",
+                          :has_annotation => "hasAnnotation",
+                          :has_equivalent => "hasEquivalent",
+                          :conforms_to => "conformsTo"]
+    desired_mappings.each_pair do |k,v|
+      SpecNode::PREDICATE_MAPPINGS.should have_key(k)
+      SpecNode::PREDICATE_MAPPINGS[k].should == v
+    end
+  end
+  
+  it 'should provide .internal_uri' do
+    @node.should  respond_to(:internal_uri)
+  end
+  
+  it 'should provide #has_relationship' do
+    SpecNode.should  respond_to(:has_relationship)
+    SpecNode.should  respond_to(:has_relationship)
+  end
+  
+  describe '#has_relationship' do
+    it "should create finders based on provided relationship name" 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)
+      local_node.should_not respond_to(:containers)
+      SpecNode.has_relationship("containers", :is_member_of)  
+      local_node.should respond_to(:containers_ids)
+    end
+    
+    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)
+    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)
+    end
+    
+    it 'should create inbound relationship finders' do
+      SpecNode.expects(:create_inbound_relationship_finders)
+      SpecNode.has_relationship("parts", :is_part_of, :inbound => true) 
+    end
+    
+    it 'should create outbound relationship finders' do
+      SpecNode.expects(:create_outbound_relationship_finders).times(2)
+      SpecNode.has_relationship("parts", :is_part_of, :inbound => false)
+      SpecNode.has_relationship("container", :is_member_of)
+    end
+    
+    it "should create outbound relationship finders that return an array of fedora PIDs" do
+      SpecNode.has_relationship("containers", :is_member_of, :inbound => false)
+      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") )
+      containers_result = local_node.containers_ids
+      containers_result.should be_instance_of(Array)
+      containers_result.should include("container:A")
+      containers_result.should include("container:B")
+    end
+    
+  end
+    
+  describe '#create_inbound_relationship_finders' do
+    
+    it 'should respond to #create_inbound_relationship_finders' do
+      SpecNode.should respond_to(:create_inbound_relationship_finders)
+    end
+    
+    it "should create finders based on provided relationship name" do
+      SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
+      local_node = SpecNode.new
+      local_node.should respond_to(:parts_ids)
+      local_node.should_not respond_to(:containers)
+      SpecNode.create_inbound_relationship_finders("containers", :is_member_of, :inbound => true)  
+      local_node.should respond_to(:containers_ids)
+      local_node.should respond_to(:containers)
+    end
+    
+    it "resulting finder should search against solr and use Model#load_instance to build an array of objects" do
+      solr_result = (mock("solr result", :is_a? => true, :hits => @sample_solr_hits))
+      mock_repo = mock("repo")
+      mock_repo.expects(:find_model).with("_PID1_", "AudioRecord").returns("AR1")
+      mock_repo.expects(:find_model).with("_PID2_", "AudioRecord").returns("AR2")
+      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")
+      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid").returns(solr_result)
+      Fedora::Repository.expects(:instance).returns(mock_repo).times(3)
+      Kernel.expects(:const_get).with("AudioRecord").returns("AudioRecord").times(3)
+      local_node.parts.should == ["AR1", "AR2", "AR3"]
+    end
+    
+    it "resulting finder should accept :solr as :response_format value and return the raw Solr Result" do
+      solr_result = mock("solr result")
+      SpecNode.create_inbound_relationship_finders("constituents", :is_constituent_of, :inbound => true)
+      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")
+      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_constituent_of_s:info\\:fedora/test\\:sample_pid").returns(solr_result)
+      local_node.constituents(:response_format => :solr).should equal(solr_result)
+    end
+    
+    
+    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")
+      ActiveFedora::SolrService.instance.conn.expects(:query).with("is_part_of_s:info\\:fedora/test\\:sample_pid").returns(mock("solr result", :hits => [Hash["id"=>"pid1"], Hash["id"=>"pid2"]]))
+      local_node.parts(:response_format => :id_array).should == ["pid1", "pid2"]
+    end
+    
+    it "resulting _ids finder should call the basic finder with :result_format => :id_array" do
+      SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
+      local_node = SpecNode.new
+      local_node.expects(:parts).with(:response_format => :id_array)
+      local_node.parts_ids
+    end
+    
+    it "resulting finder should provide option of filtering results by :type"
+  end
+  
+  describe '#create_outbound_relationship_finders' do
+    
+    it 'should respond to #create_outbound_relationship_finders' do
+      SpecNode.should respond_to(:create_outbound_relationship_finders)
+    end
+    
+    it "should create finders based on provided relationship name" do
+      SpecNode.create_outbound_relationship_finders("parts", :is_part_of)
+      local_node = SpecNode.new
+      local_node.should respond_to(:parts_ids)
+      #local_node.should respond_to(:parts)  #.with(:type => "AudioRecord")  
+      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)      
+    end
+    
+    describe " resulting finder" 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)      
+        mock_repo = mock("repo")
+        solr_result = mock("solr result", :is_a? => true)
+        solr_result.expects(:hits).returns([{"id"=> "my:_PID1_", "active_fedora_model_s" => "SpecNode"}, {"id"=> "my:_PID2_", "active_fedora_model_s" => "SpecNode"}, {"id"=> "my:_PID3_", "active_fedora_model_s" => "SpecNode"}])
+        ActiveFedora::SolrService.instance.conn.expects(:query).with("id:my\\:_PID1_ OR id:my\\:_PID2_ OR id:my\\:_PID3_").returns(solr_result)
+        mock_repo.expects(:find_model).with("my:_PID1_", SpecNode).returns("AR1")
+        mock_repo.expects(:find_model).with("my:_PID2_", SpecNode).returns("AR2")
+        mock_repo.expects(:find_model).with("my:_PID3_", SpecNode).returns("AR3")
+        Fedora::Repository.expects(:instance).returns(mock_repo).times(3)
+        local_node.containers.should == ["AR1", "AR2", "AR3"]
+      end
+    
+      it "should accept :solr as :response_format value and return the raw Solr Result" do
+        solr_result = mock("solr result")
+        SpecNode.create_outbound_relationship_finders("constituents", :is_constituent_of)
+        local_node = SpecNode.new
+        mock_repo = mock("repo")
+        mock_repo.expects(:find_model).never
+        local_node.stubs(:internal_uri)
+        ActiveFedora::SolrService.instance.conn.expects(:query).returns(solr_result)
+        local_node.constituents(:response_format => :solr).should equal(solr_result)
+      end
+      
+      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.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)
+        result = local_node.containers_ids
+        puts local_node.relationships.inspect
+        #puts local_node.outbound_relationships.inspect
+        puts local_node.internal_uri
+        result.should be_instance_of(Array)
+        result.should include("demo:10")
+      end
+      
+      it "should provide option of filtering results by :type"
+    end
+    
+    describe " resulting _ids finder" do
+      it "should call the basic finder with :result_format => :id_array" do
+        SpecNode.create_outbound_relationship_finders("parts", :is_part_of)
+        local_node = SpecNode.new
+        local_node.expects(:parts).with(:response_format => :id_array)
+        local_node.parts_ids
+      end
+    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)
+    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.relationships[:self][:is_member_of].should == ["info:fedora/demo:10"]      
+      local_test_node2.relationships[:self][:is_member_of].should be_nil
+    end
+    
+  end
+  
+  describe '#relationships' do
+    
+    it "should return a hash" do
+      SpecNode.relationships.class.should == Hash
+    end
+
+  end
+
+    
+  it "should provide a relationship setter"
+  it "should provide a relationship getter"
+  it "should provide a relationship deleter"
+      
+  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")
+    end
+    
+    it "should not be a class level method"
+  end
+  
+  it 'should provide #predicate_lookup that maps symbols to common RELS-EXT predicates' do
+    SpecNode.should respond_to(:predicate_lookup)
+    SpecNode.predicate_lookup(:is_part_of).should == "isPartOf"
+    SpecNode.predicate_lookup(:is_member_of).should == "isMemberOf"
+    SpecNode.predicate_lookup("isPartOfCollection").should == "isPartOfCollection"
+  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#'/>
+        </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.internal_uri = @uri
+      returned_xml = XmlSimple.xml_in(@node.to_rels_ext(@pid))
+      returned_xml.should == XmlSimple.xml_in(@sample_rels_ext_xml)
+    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
+  
+end