active-fedora 3.2.0.pre1 → 3.2.0.pre2

data/spec/integration/full_featured_model_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'rexml/document'
-require "active_fedora/samples"
 
 include ActiveFedora
 

data/spec/integration/mods_article_integration_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require "active_fedora/samples"
 
 describe ActiveFedora::Base do
 

data/spec/integration/nokogiri_datastream_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require "active_fedora/samples"
 require "solrizer"
 
 describe ActiveFedora::NokogiriDatastream do

data/spec/integration/rels_ext_datastream_spec.rb

@@ -3,12 +3,6 @@ require 'spec_helper'
 require 'active_fedora'
 require "rexml/document"
 
-class MockAFRelsSolr < ActiveFedora::Base
-  has_relationship "testing", :has_part, :type=>MockAFRelsSolr
-  has_relationship "testing2", :has_member, :type=>MockAFRelsSolr
-  has_relationship "testing_inbound", :has_part, :type=>MockAFRelsSolr, :inbound=>true
-  has_relationship "testing_inbound2", :has_member, :type=>MockAFRelsSolr, :inbound=>true
-end
 
 describe ActiveFedora::RelsExtDatastream do
   
@@ -85,7 +79,16 @@ describe ActiveFedora::RelsExtDatastream do
   end
 
   describe '#from_solr' do
-    
+    before do
+      ActiveSupport::Deprecation.stubs(:warn)
+      class MockAFRelsSolr < ActiveFedora::Base
+        include ActiveFedora::FileManagement
+        has_relationship "testing", :has_part, :type=>MockAFRelsSolr
+        has_relationship "testing2", :has_member, :type=>MockAFRelsSolr
+        has_relationship "testing_inbound", :has_part, :type=>MockAFRelsSolr, :inbound=>true
+        has_relationship "testing_inbound2", :has_member, :type=>MockAFRelsSolr, :inbound=>true
+      end
+    end
     it "should respond_to from_solr" do
       @test_datastream.respond_to?(:from_solr).should be_true
     end

data/spec/integration/semantic_node_spec.rb

@@ -6,8 +6,6 @@ describe ActiveFedora::SemanticNode do
   
   before(:all) do 
     class SNSpecNode < ActiveFedora::Base
-      # include ActiveFedora::RelationshipsHelper
-      # include ActiveFedora::SemanticNode
       # has_relationship "collection_members", :has_collection_member
       # attr_accessor :rels_ext
       # def initialize
@@ -163,11 +161,11 @@ describe ActiveFedora::SemanticNode do
   describe "inbound relationship finders" do
     describe "when inheriting from parents" do
       before do
+        @part4 = ActiveFedora::Base.new()
+        @part4.parts  ## Includes the FileManagement onto AF::Base. This happens in another test (and caries into this one) if you run the whole suite, but it doesn't get set up if you just run this test.
         class Test2 < ActiveFedora::Base
-          # has_bidirectional_relationship "components", :has_component, :is_component_of
         end
         class Test3 < Test2
-          # has_bidirectional_relationship "components", :has_component, :is_component_of
           has_relationship "testing", :has_member
         end
 
@@ -181,7 +179,6 @@ describe ActiveFedora::SemanticNode do
  
         @test_object2 = Test2.new
         @test_object2.save
-        @part4 = ActiveFedora::Base.new()
       end
       it "should have relationships defined" do
         # puts "Test2 relationships_desc:"
@@ -433,17 +430,14 @@ describe ActiveFedora::SemanticNode do
 
   #putting this test here instead of relationships_helper because testing that relationships_by_name hash gets refreshed if the relationships hash is changed
   describe "relationships_by_name" do
-    class MockSemNamedRelationships  < ActiveFedora::Base
-      # include ActiveFedora::RelationshipsHelper
-      # include ActiveFedora::SemanticNode
-      has_relationship "testing", :has_part
-      has_relationship "testing2", :has_member
-      has_relationship "testing_inbound", :has_part, :inbound=>true
-      # attr_accessor :rels_ext
-      # def initialize
-      #   self.rels_ext = ActiveFedora::RelsExtDatastream.new(nil, nil)
-      #   rels_ext.model = self
-      # end
+    before do
+      ActiveSupport::Deprecation.stubs(:warn)
+      class MockSemNamedRelationships  < ActiveFedora::Base
+        include ActiveFedora::FileManagement
+        has_relationship "testing", :has_part
+        has_relationship "testing2", :has_member
+        has_relationship "testing_inbound", :has_part, :inbound=>true
+      end
     end
 
     it 'should automatically update the relationships_by_name if relationships has changed (no refresh of relationships_by_name hash unless relationships hash has changed' do

data/spec/samples/models/hydrangea_article.rb

@@ -1,5 +1,4 @@
 require "active-fedora"
-require "active_fedora/samples"
 
 # This Model is used to load & index the hydrangea:fixture_mods_article1 fixture for use in tests.
 #
@@ -9,4 +8,4 @@ class HydrangeaArticle < ActiveFedora::Base
   has_metadata :name => "descMetadata", :type=> Hydra::ModsArticleDatastream  
   has_metadata :name => "rightsMetadata", :type => Hydra::RightsMetadataDatastream
 
-end
+end

data/spec/samples/oral_history_sample_model.rb

@@ -1,7 +1,7 @@
 require "active_fedora"
 class OralHistorySampleModel < ActiveFedora::Base
 
-    has_relationship "parts", :is_part_of, :inbound => true
+    #has_relationship "parts", :is_part_of, :inbound => true
     
     has_metadata :name => "properties", :type => ActiveFedora::MetadataDatastream do |m|
       m.field "narrator",  :string

data/spec/unit/base_spec.rb

@@ -40,7 +40,7 @@ describe ActiveFedora::Base do
   after(:each) do
     begin
     ActiveFedora::SolrService.stubs(:instance)
-    @test_object.delete
+    #@test_object.delete
     rescue
     end
   end
@@ -830,16 +830,17 @@ describe ActiveFedora::Base do
     FooHistory.solr_search("pid: foobar", {:ding=>:dang}).should == {:baz=>:bif}
   end
 
-  it 'should provide #relationships_by_name' do
-    @test_object.should respond_to(:relationships_by_name)
-  end
-  
   describe '#relationships_by_name' 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
+    before do
+      ActiveSupport::Deprecation.stubs(:warn)
+
+      class MockNamedRelationships < ActiveFedora::Base
+        include ActiveFedora::FileManagement
+        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
     end
     
     it 'should return current relationships by name' do
@@ -851,17 +852,26 @@ describe ActiveFedora::Base do
       @test_object.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(ActiveFedora::Base))
       #should return expected named relationships
       @test_object2.relationships_by_name
-      @test_object2.relationships_by_name.should == {:self=>{"testing2"=>[], "collection_members"=>[], "part_of"=>[], "testing"=>[], "parts_outbound"=>[]}}
+      @test_object2.relationships_by_name[:self]["testing"].should == []
+      @test_object2.relationships_by_name[:self]["testing2"].should == []
+      @test_object2.relationships_by_name[:self]["parts_outbound"].should == []
       @test_object2.add_relationship_by_name("testing",@test_object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>[],"part_of"=>[], "parts_outbound"=>[@test_object.internal_uri], "collection_members"=>[]}}
+      # @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>[],"part_of"=>[], "parts_outbound"=>[@test_object.internal_uri], "collection_members"=>[]}}
+
+      @test_object2.relationships_by_name[:self]["testing"].should == [@test_object.internal_uri]
+      @test_object2.relationships_by_name[:self]["testing2"].should == []
+      @test_object2.relationships_by_name[:self]["parts_outbound"].should == [@test_object.internal_uri]
     end 
   end
 
   
   describe '#create_relationship_name_methods' do
-    class MockCreateNamedRelationshipMethodsBase < ActiveFedora::Base
-      register_relationship_desc :self, "testing", :is_part_of, :type=>ActiveFedora::Base
-      create_relationship_name_methods "testing"
+    before do
+      ActiveSupport::Deprecation.stubs(:warn)
+      class MockCreateNamedRelationshipMethodsBase < ActiveFedora::Base
+        register_relationship_desc :self, "testing", :is_part_of, :type=>ActiveFedora::Base
+        create_relationship_name_methods "testing"
+      end
     end
       
     it 'should append and remove using helper methods for each outbound relationship' do
@@ -877,9 +887,9 @@ describe ActiveFedora::Base do
       @test_object2.add_relationship(:has_model,model_pid)
       @test_object2.testing_append(@test_object)
       #create relationship to access generate_uri method for an object
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"collection_members"=>[], "part_of"=>[@test_object.internal_uri], "parts_outbound"=>[]}}
+      @test_object2.relationships_by_name[:self]["testing"].should == [@test_object.internal_uri]
       @test_object2.testing_remove(@test_object)
-      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"collection_members"=>[], "part_of"=>[], "parts_outbound"=>[]}}
+      @test_object2.relationships_by_name[:self]["testing"].should == []
     end
   end
 

data/spec/unit/metadata_datastream_spec.rb

@@ -44,6 +44,7 @@ describe ActiveFedora::MetadataDatastream do
       @mock_repo.expects(:datastream).with(:pid => nil, :dsid => 'mdDs')
       @mock_repo.expects(:add_datastream).with(:pid => nil, :dsid => 'mdDs', :checksumType => 'DISABLED', :versionable => true, :content => 'fake xml', :controlGroup => 'M', :dsState => 'A', :mimeType=>'text/xml')
       @test_ds.expects(:to_xml).returns("fake xml")
+      @test_ds.expects(:dirty?).returns(true)
       @test_ds.serialize!
       @test_ds.save
       @test_ds.mimeType.should == 'text/xml'

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -129,6 +129,7 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
     it "should call .content= with to_dc_xml" do
       result = @test_ds.to_dc_xml
       @test_ds.expects(:content=).with(result)
+      @test_ds.expects(:dirty?).returns(true)
       @test_ds.serialize!
     end
   end

data/spec/unit/relationship_spec.rb

@@ -87,5 +87,6 @@ describe ActiveFedora::Relationship do
       @test_relationship.predicate.should == "isComponentOf"
     end
   end
+
   
 end

data/spec/unit/relationships_spec.rb

@@ -0,0 +1,846 @@
+require 'spec_helper'
+
+@@last_pid = 0
+
+describe ActiveFedora::Relationships do
+    def increment_pid
+      @@last_pid += 1    
+    end
+
+    before(:each) do
+      class SpecNode
+        include ActiveFedora::Relationships
+        include ActiveFedora::SemanticNode
+        
+        attr_accessor :pid
+        def initialize (params={}) 
+          self.pid = params[:pid]
+        end
+        def internal_uri
+          'info:fedora/' + pid.to_s
+        end
+      end
+    end
+    after(:each) do
+      Object.send(:remove_const, :SpecNode)
+    end
+
+    it 'should provide #has_relationship' do
+      SpecNode.should  respond_to(:has_relationship)
+      SpecNode.should  respond_to(:has_relationship)
+    end
+    describe '#relationships' do
+      
+      it "should return a hash" do
+        SpecNode.relationships.class.should == Hash
+      end
+
+    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_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
+        SpecNode.has_relationship("parents", :is_part_of)
+        SpecNode.relationships.should have_key(:self)
+        SpecNode.relationships[:self].should have_key(:is_part_of)
+      end
+      
+      it "should use :inbound as the subject if :inbound => true" do
+        SpecNode.has_relationship("parents", :is_part_of, :inbound => true)
+        SpecNode.relationships.should have_key(:inbound)
+        SpecNode.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.pid = @pid
+        
+        local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
+        local_node.add_relationship(:is_member_of, "info:fedora/container:A")
+        local_node.add_relationship(:is_member_of, "info:fedora/container:B")
+
+        containers_result = local_node.containers_ids
+        containers_result.should be_instance_of(Array)
+        containers_result.should include("container:A")
+        containers_result.should include("container:B")
+      end
+      
+      describe "has_relationship" do
+        before do
+          class MockHasRelationship 
+            include ActiveFedora::SemanticNode
+            include ActiveFedora::Relationships
+            has_relationship "testing", :has_part, :type=>String
+            has_relationship "testing2", :has_member, :type=>String
+            has_relationship "testing_inbound", :has_part, :type=>String, :inbound=>true
+            attr_accessor :pid
+            def internal_uri
+              'info:fedora/' + pid.to_s
+            end
+          end
+        end
+        after(:each) do
+          Object.send(:remove_const, :MockHasRelationship)
+        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({})
+          @test_object2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content =>'')).at_least_once
+          @test_object2.add_relationship(:has_model, ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode))
+          @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.class.relationships_desc.should == 
+          {:inbound=>{"testing_inbound"=>{:type=>String, 
+                                         :predicate=>:has_part, 
+                                          :inbound=>true, 
+                                          :singular=>nil}}, 
+           :self=>{"testing"=>{:type=>String, 
+                               :predicate=>:has_part, 
+                               :inbound=>false, 
+                               :singular=>nil},
+                   "testing2"=>{:type=>String, 
+                                :predicate=>:has_member, 
+                                :inbound=>false, 
+                                :singular=>nil}}}
+        end
+      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)
+        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
+        @sample_solr_hits = [{"id"=>"_PID1_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
+                              {"id"=>"_PID2_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]},
+                              {"id"=>"_PID3_", "has_model_s"=>["info:fedora/afmodel:AudioRecord"]}]
+        solr_result = mock("solr result", :hits => @sample_solr_hits)
+        SpecNode.create_inbound_relationship_finders("parts", :is_part_of, :inbound => true)
+        local_node = SpecNode.new()
+        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)
+        local_node.parts_ids.should == ["_PID1_", "_PID2_", "_PID3_"]
+      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(: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
+      
+      
+      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(: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
+      
+      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 _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
+    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)  
+        local_node.should respond_to(:containers_from_solr)  
+        local_node.should respond_to(:containers_query)
+      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(:ids_for_outbound).with(:is_member_of).returns(["my:_PID1_", "my:_PID2_", "my:_PID3_"])
+          mock_repo = mock("repo")
+          solr_result = mock("solr result", :is_a? => true)
+          solr_result.expects(:hits).returns(
+                        [{"id"=> "my:_PID1_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]},
+                         {"id"=> "my:_PID2_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}, 
+                         {"id"=> "my:_PID3_", "has_model_s"=>["info:fedora/afmodel:SpecNode"]}])
+
+          ActiveFedora::SolrService.instance.conn.expects(:query).with("id:my\\:_PID1_ OR id:my\\:_PID2_ OR id:my\\:_PID3_").returns(solr_result)
+          local_node.containers.map(&:pid).should == ["my:_PID1_", "my:_PID2_", "my:_PID3_"]
+        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.expects(:rels_ext).returns(stub('rels-ext', :content=>''))
+          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(:ids_for_outbound).with(:is_member_of).returns([])
+          local_node.containers_ids
+        end
+      
+        it "(:response_format => :id_array) should return an array of fedora PIDs" do
+          SpecNode.create_outbound_relationship_finders("containers", :is_member_of)
+          local_node = SpecNode.new
+          local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
+          local_node.add_relationship(:is_member_of, "demo:10")
+          result = local_node.containers_ids
+          result.should be_instance_of(Array)
+          result.should include("demo:10")
+        end
+        
+      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
+
+      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
+      before(:each) do
+        SpecNode.create_bidirectional_relationship_finders("all_parts", :has_part, :is_part_of)
+        @local_node = SpecNode.new
+        @pid = "test:sample_pid"
+        @local_node.pid = @pid
+        #@local_node.internal_uri = @uri
+      end
+      it "should create inbound & outbound finders" do
+        @local_node.should respond_to(:all_parts_inbound)
+        @local_node.should respond_to(:all_parts_outbound)
+      end
+      it "should rely on inbound & outbound finders" do      
+        @local_node.expects(:all_parts_inbound).with(:rows => 25).returns(["foo1"])
+        @local_node.expects(:all_parts_outbound).with(:rows => 25).returns(["foo2"])
+        @local_node.all_parts.should == ["foo1", "foo2"]
+      end
+      it "(:response_format => :id_array) should rely on inbound & outbound finders" do
+        @local_node.expects(:all_parts_inbound).with(:response_format=>:id_array, :rows => 34).returns(["fooA"])
+        @local_node.expects(:all_parts_outbound).with(:response_format=>:id_array, :rows => 34).returns(["fooB"])
+        @local_node.all_parts(:response_format=>:id_array, :rows => 34).should == ["fooA", "fooB"]
+      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(:ids_for_outbound).with(:has_part).returns(["mypid:1"])
+        id_array_query = ActiveFedora::SolrService.construct_query_for_pids(["mypid:1"])
+        solr_result = mock("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
+
+      it "should register both inbound and outbound predicate components" do
+        @local_node.class.relationships[:inbound].has_key?(:is_part_of).should == true
+        @local_node.class.relationships[:self].has_key?(:has_part).should == true
+      end
+    
+      it "should register 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
+      it "should ..." do
+        SpecNode.expects(:create_bidirectional_relationship_finders).with("all_parts", :has_part, :is_part_of, {})
+        SpecNode.has_bidirectional_relationship("all_parts", :has_part, :is_part_of)
+      end
+
+      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"
+        @local_node2 = SpecNode.new
+        @local_node2.pid = "mypid2"
+        model_def = ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode)
+        @local_node.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
+        @local_node.add_relationship(:has_model, model_def)
+        @local_node2.expects(:rels_ext).returns(stub("rels_ext", :dirty= => true, :content=>'')).at_least_once
+        @local_node2.add_relationship(:has_model, model_def)
+        @local_node.add_relationship(:has_part, @local_node2)
+        @local_node2.add_relationship(:has_part, @local_node)
+        @local_node.ids_for_outbound(:has_part).should == [@local_node2.pid]
+        @local_node.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
+        @local_node2.ids_for_outbound(:has_part).should == [@local_node.pid]
+        @local_node2.ids_for_outbound(:has_model).should == ['afmodel:SpecNode']
+        @local_node.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[@local_node2.internal_uri]},:inbound=>{"all_parts_inbound"=>[]}}
+        @local_node2.relationships_by_name(false).should == {:self=>{"all_parts_outbound"=>[@local_node.internal_uri]},:inbound=>{"all_parts_inbound"=>[]}}
+      end
+    end
+
+  
+  it 'should provide #inbound_relationship_names' do
+    SpecNode.new.should respond_to(:inbound_relationship_names)
+  end
+  
+  describe '#inbound_relationship_names' do
+    before do
+      class MockRelationshipNames < SpecNode
+        register_relationship_desc(:self, "testing", :has_part, :type=>SpecNode)
+        create_relationship_name_methods("testing")
+        register_relationship_desc(:self, "testing2", :has_member, :type=>SpecNode)
+        create_relationship_name_methods("testing2")
+        register_relationship_desc(:inbound, "testing_inbound", :has_part, :type=>SpecNode)
+        register_relationship_desc(:inbound, "testing_inbound2", :has_member, :type=>SpecNode)
+      end
+    end
+    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
+    SpecNode.new.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 #inbound_relationships_by_name' do
+    #testing execution of this in integration since touches solr
+    SpecNode.new.should respond_to(:inbound_relationships_by_name)
+  end
+  
+  it 'should provide #find_relationship_by_name' do
+    SpecNode.new.should respond_to(:find_relationship_by_name)
+  end
+  
+  describe '#find_relationship_by_name' do
+    it 'should return an array of object uri for a given relationship name' do
+      @test_object2 = MockRelationshipNames.new
+      @test_object2.pid = increment_pid
+      @test_object3 = SpecNode.new 
+      @test_object3.pid = increment_pid
+      @test_object4 = SpecNode.new 
+      @test_object4.pid = increment_pid
+      #add relationships that mirror 'testing' and 'testing2'
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new(ActiveFedora::ContentModel.pid_from_ruby_class(MockRelationshipNames)))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_member),  RDF::URI.new(@test_object4.internal_uri))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_part),  RDF::URI.new(@test_object3.internal_uri))
+      @test_object2.expects(:relationships).returns(graph).at_least_once
+     @test_object2.find_relationship_by_name("testing").should == [@test_object3.internal_uri] 
+    end
+  end
+
+  describe "relationship_query" do
+    before do
+      class MockNamedRelationshipQuery < SpecNode
+        register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:inbound, "testing_inbound_no_solr_fq", :is_part_of, :type=>SpecNode)
+        register_relationship_desc(:self, "testing_outbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:self, "testing_outbound_no_solr_fq", :is_part_of, :type=>SpecNode)
+        #for bidirectional relationship testing need to register both outbound and inbound names
+        register_relationship_desc(:self, "testing_bi_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:inbound, "testing_bi_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+        register_relationship_desc(:self, "testing_bi_no_solr_fq_outbound", :has_part, :type=>SpecNode)
+        register_relationship_desc(:inbound, "testing_bi_no_solr_fq_inbound", :is_part_of, :type=>SpecNode)
+      end
+    end
+    after do
+      Object.send(:remove_const, :MockNamedRelationshipQuery)
+    end
+    
+    before(:each) do
+      @mockrelsquery = MockNamedRelationshipQuery.new
+    end
+    
+    it "should call bidirectional_relationship_query if a bidirectional relationship" do
+      ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+      @mockrelsquery.expects(:ids_for_outbound).with(:has_part).returns(ids).at_least_once
+      @mockrelsquery.expects(:pid).returns("changeme:5")
+      MockNamedRelationshipQuery.expects(:bidirectional_relationship_query).with("changeme:5","testing_bi_query",ids)
+      @mockrelsquery.relationship_query("testing_bi_query")
+    end
+    
+    it "should call outbound_relationship_query if an outbound relationship" do
+      ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+      @mockrelsquery.expects(:ids_for_outbound).with(:is_part_of).returns(ids).at_least_once
+      MockNamedRelationshipQuery.expects(:outbound_relationship_query).with("testing_outbound_no_solr_fq",ids)
+      @mockrelsquery.relationship_query("testing_outbound_no_solr_fq")
+    end
+    
+    it "should call inbound_relationship_query if an inbound relationship" do
+      @mockrelsquery.expects(:pid).returns("changeme:5")
+      MockNamedRelationshipQuery.expects(:inbound_relationship_query).with("changeme:5","testing_inbound_query")
+      @mockrelsquery.relationship_query("testing_inbound_query")
+    end
+  end
+
+  describe '#relationship_predicates' do
+    before do
+      class MockNamedRelationshipPredicates < SpecNode
+        register_relationship_desc(:self, "testing", :has_part, :type=>SpecNode)
+        create_relationship_name_methods("testing")
+        register_relationship_desc(:self, "testing2", :has_member, :type=>SpecNode)
+        create_relationship_name_methods("testing2")
+        register_relationship_desc(:inbound, "testing_inbound", :has_part, :type=>SpecNode)
+      end
+    end
+    after do
+      Object.send(:remove_const, :MockNamedRelationshipPredicates)
+    end
+
+    it 'should provide #relationship_predicates' do
+      SpecNode.new.should respond_to(:relationship_predicates)
+    end
+    
+    it 'should return a map of subject to relationship name to fedora ontology relationship predicate' do
+      @test_object2 = MockNamedRelationshipPredicates.new
+      @test_object2.relationship_predicates.should == {:self=>{"testing"=>:has_part,"testing2"=>:has_member},
+                                                            :inbound=>{"testing_inbound"=>:has_part}}
+      
+    end 
+  end
+  
+  describe '#conforms_to?' do
+    before do
+      @test_object = SpecNode.new
+    end
+    it 'should provide #conforms_to?' do
+      @test_object.should respond_to(:conforms_to?)
+    end
+    
+    it 'should check if current object is the kind of model class supplied' do
+      #has_model relationship does not get created until save called
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new(ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode)))
+      @test_object.expects(:relationships).returns(graph).at_least_once
+      @test_object.conforms_to?(SpecNode).should == true
+    end
+  end
+  
+  describe '#assert_conforms_to' do
+    before do
+      @test_object = SpecNode.new
+    end
+    it 'should provide #assert_conforms_to' do
+      @test_object.should respond_to(:assert_conforms_to)
+    end
+
+    it 'should correctly assert if an object is the type of model supplied' do
+      @test_object3 = SpecNode.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
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new(ActiveFedora::ContentModel.pid_from_ruby_class(SpecNode)))
+      @test_object.expects(:relationships).returns(graph).at_least_once
+      @test_object3.assert_conforms_to('object',@test_object,SpecNode)
+    end
+  end
+  
+  it 'should provide #class_from_name' do
+    SpecNode.new.should respond_to(:class_from_name)
+  end
+  
+  describe '#class_from_name' do
+    it 'should return a class constant for a string passed in' do
+      SpecNode.new.class_from_name("SpecNode").should == SpecNode
+    end
+  end
+
+  describe '#relationships_by_name' do
+    
+    before do
+      class MockNamedRelationships3 < SpecNode
+        register_relationship_desc(:self, "testing", :has_part, :type=>SpecNode)
+        create_relationship_name_methods("testing")
+        register_relationship_desc(:self, "testing2", :has_member, :type=>SpecNode)
+        create_relationship_name_methods("testing2")
+        register_relationship_desc(:inbound, "testing_inbound", :has_part, :type=>SpecNode)
+      end
+    end
+    after do
+      Object.send(:remove_const, :MockNamedRelationships3)
+    end
+
+    it 'should provide #relationships_by_name' do
+      @test_object = SpecNode.new
+      @test_object.should respond_to(:relationships_by_name)
+    end
+    
+    it 'should return current named relationships' do
+      @test_object = SpecNode.new
+      @test_object.pid = increment_pid
+      @test_object2 = MockNamedRelationships3.new
+      @test_object2.pid = increment_pid
+      @test_object3 = MockNamedRelationships3.new
+      @test_object3.pid = increment_pid
+      model_pid = ActiveFedora::ContentModel.pid_from_ruby_class(MockNamedRelationships3)
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new(model_pid))
+      @test_object2.expects(:relationships).returns(graph).at_least_once
+      #should return expected named relationships
+      @test_object2.relationships_by_name.should == {:self=>{"testing"=>[],"testing2"=>[]}}
+      graph = RDF::Graph.new
+      subject = RDF::URI.new "info:fedora/test:sample_pid"
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_model),  RDF::URI.new(model_pid))
+      graph.insert RDF::Statement.new(subject, ActiveFedora::Predicates.find_graph_predicate(:has_part),  RDF::URI.new(@test_object.internal_uri))
+      @test_object3.expects(:relationships).returns(graph).at_least_once
+      @test_object3.relationships_by_name.should == {:self=>{"testing"=>[@test_object.internal_uri],"testing2"=>[]}}
+    end 
+  end
+  describe '#relationship_has_solr_filter_query' do
+    before do
+      class RelsHasSolrFilter < SpecNode
+        register_relationship_desc :self, "testing", :is_part_of, :solr_fq=>"testing:value"
+        register_relationship_desc :self, "no_query_testing", :is_part_of
+        register_relationship_desc :inbound, "inbound_testing", :has_part, :solr_fq=>"in_testing:value_in"
+        register_relationship_desc :inbound, "inbound_testing_no_query", :has_part
+      end
+      @test_object = RelsHasSolrFilter.new
+    end
+    after do
+      Object.send(:remove_const, :RelsHasSolrFilter)
+    end
+
+    it 'should return true if an object has an inbound relationship with solr filter query' do
+      @test_object.relationship_has_solr_filter_query?(:inbound,"inbound_testing").should == true
+    end
+
+    it 'should return false if an object does not have inbound relationship with solr filter query' do
+      @test_object.relationship_has_solr_filter_query?(:inbound,"inbound_testing_no_query").should == false
+    end
+
+    it 'should return true if an object has an outbound relationship with solr filter query' do
+      @test_object.relationship_has_solr_filter_query?(:self,"testing").should == true
+    end
+
+    it 'should return false if an object does not have outbound relationship with solr filter query' do
+      @test_object.relationship_has_solr_filter_query?(:self,"testing_no_query").should == false
+    end
+  end
+
+  describe ActiveFedora::Relationships::ClassMethods do
+
+     after(:each) do
+      begin
+        @test_object2.delete
+      rescue
+      end
+    end
+
+    describe '#relationships_desc' do
+      it 'should initialize relationships_desc to a new hash containing self' do
+        @test_object2 = SpecNode.new
+        @test_object2.pid = increment_pid
+        @test_object2.relationships_desc.should == {:self=>{}}
+      end
+    end
+      
+    describe '#register_relationship_desc_subject' do
+    
+      before do
+        class MockRegisterNamedSubject < SpecNode
+          register_relationship_desc_subject :test
+        end
+      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.relationships_desc.should == {:self=>{}, :test=>{}}
+      end 
+    end
+  
+    describe '#register_relationship_desc' do
+    
+      before do
+        class MockRegisterNamedRelationship < SpecNode
+          register_relationship_desc :self, "testing", :is_part_of, :type=>SpecNode
+          register_relationship_desc :inbound, "testing2", :has_part, :type=>SpecNode
+        end
+      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.relationships_desc.should == {:inbound=>{"testing2"=>{:type=>SpecNode, :predicate=>:has_part}}, :self=>{"testing"=>{:type=>SpecNode, :predicate=>:is_part_of}}}
+      end 
+    end
+
+    describe "#is_bidirectional_relationship?" do
+      
+      before do
+        class MockIsBiRegisterNamedRelationship < SpecNode
+          register_relationship_desc(:self, "testing_outbound", :is_part_of, :type=>SpecNode)
+          register_relationship_desc(:inbound, "testing_inbound", :has_part, :type=>SpecNode)
+          register_relationship_desc(:self, "testing2", :is_member_of,{})
+        end
+      end
+
+      it "should return true if both inbound and outbound predicates exist, otherwise false" do
+        MockIsBiRegisterNamedRelationship.is_bidirectional_relationship?("testing").should == true
+        MockIsBiRegisterNamedRelationship.is_bidirectional_relationship?("testing2").should == false
+        #the inbound and outbound internal relationships will not be bidirectional by themselves
+        MockIsBiRegisterNamedRelationship.is_bidirectional_relationship?("testing_inbound").should == false
+        MockIsBiRegisterNamedRelationship.is_bidirectional_relationship?("testing_outbound").should == false
+      end
+    end
+
+
+    describe '#create_relationship_name_methods' do
+      before do
+        class MockCreateNamedRelationshipMethods < SpecNode
+          register_relationship_desc :self, "testing", :is_part_of, :type=>SpecNode
+          create_relationship_name_methods "testing"
+        end
+      end
+      after do
+        Object.send(:remove_const, :MockCreateNamedRelationshipMethods)
+      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_relationship_name_methods' do
+      before do
+        class MockCreateNamedRelationshipMethods < SpecNode
+          register_relationship_desc(:self, "testing_outbound", :is_part_of, :type=>SpecNode)
+          create_bidirectional_relationship_name_methods "testing", "testing_outbound"
+        end
+      end
+      after do
+        Object.send(:remove_const, :MockCreateNamedRelationshipMethods)
+      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
+    
+
+     #
+    # HYDRA-541
+    #
+      
+    describe "bidirectional_relationship_query" do
+      before do
+        class MockBiNamedRelationshipQuery < SpecNode
+          register_relationship_desc(:self, "testing_query_outbound", :has_part, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+          register_relationship_desc(:inbound, "testing_query_inbound", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+          create_bidirectional_relationship_name_methods("testing","testing_outbound")
+          register_relationship_desc(:self, "testing_no_solr_fq_outbound", :has_part, :type=>SpecNode)
+          register_relationship_desc(:inbound, "testing_no_solr_fq_inbound", :is_part_of, :type=>SpecNode)
+          create_bidirectional_relationship_name_methods("testing_no_solr_fq","testing_no_solr_fq_outbound")
+        end
+      end
+      after do
+        Object.send(:remove_const, :MockBiNamedRelationshipQuery)
+      end
+
+      #
+      # HYDRA-541
+      #
+      it "should rely on outbound query if inbound query is empty" do
+        query = MockBiNamedRelationshipQuery.bidirectional_relationship_query("PID",:testing_query,[])
+        query.should_not include("OR ()")
+        query2 = MockBiNamedRelationshipQuery.bidirectional_relationship_query("PID",:testing_no_solr_fq,[])
+        query2.should_not include("OR ()")
+      end
+
+      it "should return a properly formatted query for a relationship that has a solr filter query defined" do
+        expected_string = ""
+        ids = ["changeme:1","changeme:2","changeme:3","changeme:4","changeme:5"]
+        ids.each_with_index do |id,index|
+          expected_string << " OR " if index > 0
+          expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialPart)"
+        end
+        expected_string << " OR "
+        expected_string << "(is_part_of_s:info\\:fedora/changeme\\:6 AND has_model_s:info\\:fedora/SpecialPart)"
+        MockBiNamedRelationshipQuery.bidirectional_relationship_query("changeme:6","testing_query",ids).should == expected_string
+      end
+
+      it "should return a properly formatted query for a relationship that does not have a solr filter query defined" do
+        expected_string = ""
+        ids = ["changeme:1","changeme:2","changeme:3","changeme:4","changeme:5"]
+        ids.each_with_index do |id,index|
+          expected_string << " OR " if index > 0
+          expected_string << "id:" + id.gsub(/(:)/, '\\:')
+        end
+        expected_string << " OR "
+        expected_string << "(is_part_of_s:info\\:fedora/changeme\\:6)"
+        MockBiNamedRelationshipQuery.bidirectional_relationship_query("changeme:6","testing_no_solr_fq",ids).should == expected_string
+      end
+    end
+
+    describe "inbound_relationship_query" do
+      before do
+        class MockInboundNamedRelationshipQuery < SpecNode
+          register_relationship_desc(:inbound, "testing_inbound_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+          register_relationship_desc(:inbound, "testing_inbound_no_solr_fq", :is_part_of, :type=>SpecNode)
+        end
+      end
+      after(:each) do
+        Object.send(:remove_const, :MockInboundNamedRelationshipQuery)
+      end
+
+      it "should return a properly formatted query for a relationship that has a solr filter query defined" do
+        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_query").should == "is_part_of_s:info\\:fedora/changeme\\:1 AND has_model_s:info\\:fedora/SpecialPart"
+      end
+      
+      it "should return a properly formatted query for a relationship that does not have a solr filter query defined" do
+        MockInboundNamedRelationshipQuery.inbound_relationship_query("changeme:1","testing_inbound_no_solr_fq").should == "is_part_of_s:info\\:fedora/changeme\\:1"
+      end
+    end
+
+
+
+
+    describe "outbound_relationship_query" do
+      before do
+        class MockOutboundNamedRelationshipQuery < SpecNode
+          register_relationship_desc(:self, "testing_query", :is_part_of, :type=>SpecNode, :solr_fq=>"has_model_s:info\\:fedora/SpecialPart")
+          register_relationship_desc(:self,"testing_no_solr_fq", :is_part_of, :type=>SpecNode)
+        end
+      end
+      after(:each) do
+        Object.send(:remove_const, :MockOutboundNamedRelationshipQuery)
+      end
+
+      it "should return a properly formatted query for a relationship that has a solr filter query defined" do
+        ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+        expected_string = ""
+        ids.each_with_index do |id,index|
+          expected_string << " OR " if index > 0
+          expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialPart)"
+        end
+        MockOutboundNamedRelationshipQuery.outbound_relationship_query("testing_query",ids).should == expected_string
+      end
+
+      it "should return a properly formatted query for a relationship that does not have a solr filter query defined" do
+        expected_string = ""
+        ids = ["changeme:1","changeme:2","changeme:3","changeme:4"]
+        ids.each_with_index do |id,index|
+          expected_string << " OR " if index > 0
+          expected_string << "id:" + id.gsub(/(:)/, '\\:')
+        end
+        MockOutboundNamedRelationshipQuery.outbound_relationship_query("testing_no_solr_fq",ids).should == expected_string
+      end
+    end 
+  end
+end