active-fedora 2.3.0 → 2.3.1

data/lib/active_fedora/samples/sample_af_obj_relationship_query_param.rb

@@ -0,0 +1,11 @@
+class SampleAFObjRelationshipQueryParam < ActiveFedora::Base
+  #points to all parents linked via is_member_of
+  has_relationship "parents", :is_member_of
+  #returns only parents that have a level value set to "series"
+  has_relationship "series_parents", :is_member_of, :query_params=>{:q=>{"level_t"=>"series"}}
+  #returns all parts
+  has_relationship "parts", :is_part_of, :inbound=>true
+  #returns only parts that have level to "series"
+  has_relationship "series_parts", :is_part_of, :inbound=>true, :query_params=>{:q=>{"level_t"=>"series"}}
+  has_bidirectional_relationship "bi_series_parts", :has_part, :is_part_of, :query_params=>{:q=>{"level_t"=>"series"}}
+end

data/lib/active_fedora/samples/special_thing.rb

@@ -5,10 +5,12 @@ require "active_fedora/samples/marpa-dc_datastream.rb"
 
 # This is an example of an ActiveFedora Model
 #
-# Some of the datastream ids were chosen based on the Hydra modeling conventions.  You don't have to follow them in your work.  ActiveFedora itself has no notion of those conventions, but we do encourage you to use them.
+# Some of the datastream ids were chosen based on the Hydra modeling conventions.  You don't have to follow them in your work.  
+# ActiveFedora itself has no notion of those conventions, but we do encourage you to use them.
 #
 # The Hydra conventions encourage you to have a datastream with this dsid whose contents are descriptive metadata like MODS or Dublin Core.  They especially encourage MODS.  
-# The rightsMetadata datastream is also a convention provided by the Hydra Common Metadata "content model"
+# The descMetadata dsid is a Hydra convention for a datastream with descriptive metadata contents, like MODS or Dublin Core.  They especially encourage MODS.
+# The rightsMetadata dsid is also a convention provided by the Hydra Common Metadata "content model"
 #
 # For more info on the Hydra conventions, see the documentation on "Common Metadata content model" in https://wiki.duraspace.org/display/hydra/Hydra+content+models+and+disseminators
 # Note that on the wiki, "content model" is often used to refer to Fedora CModels and/or abstract/notional models.  The Common Metadata content model is an example of this.

data/lib/active_fedora/semantic_node.rb

@@ -1,7 +1,7 @@
 module ActiveFedora
   module SemanticNode 
     include MediaShelfClassLevelInheritableAttributes
-    ms_inheritable_attributes  :class_relationships, :internal_uri, :class_named_relationships_desc
+    ms_inheritable_attributes  :class_relationships, :internal_uri
     
     attr_accessor :internal_uri, :named_relationship_desc, :relationships_are_dirty, :load_from_solr
     
@@ -442,7 +442,54 @@ module ActiveFedora
       end
       xml.to_s
     end
-    
+
+    # Returns a solr query for retrieving objects specified in a relationship.
+    # It enables the use of query_params defined within a relationship to attach a query filter
+    # on top of just the predicate being used.
+    # Instead of this method you can also use the helper method
+    # [relationship_name]_query, i.e. method "parts_query" for relationship "parts".
+    # @param [String] The name of the relationship defined in the model
+    # @return [String]
+    # @example
+    #   Class SampleAFObjRelationshipQueryParam < ActiveFedora::Base
+    #     #points to all parents linked via is_member_of
+    #     has_relationship "parents", :is_member_of
+    #     #returns only parents that have a level value set to "series"
+    #     has_relationship "series_parents", :is_member_of, :query_params=>{:q=>{"level_t"=>"series"}}
+    #   end
+    #   s = SampleAFObjRelationshipQueryParam.new
+    #   obj = ActiveFedora::Base.new
+    #   s.parents_append(obj)
+    #   s.series_parents_query 
+    #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+    #   SampleAFObjRelationshipQueryParam.named_relationship_query("series_parents")
+    #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+    def named_relationship_query(relationship_name)
+      query = ""
+      if self.class.is_bidirectional_relationship?(relationship_name)
+        id_array = []
+        predicate = outbound_named_relationship_predicates["#{relationship_name}_outbound"]
+        if !outbound_relationships[predicate].nil? 
+          outbound_relationships[predicate].each do |rel|
+            id_array << rel.gsub("info:fedora/", "")
+          end
+        end
+        query = self.class.bidirectional_named_relationship_query(pid,relationship_name,id_array)
+      elsif outbound_relationship_names.include?(relationship_name)
+        id_array = []
+        predicate = outbound_named_relationship_predicates[relationship_name]
+        if !outbound_relationships[predicate].nil? 
+          outbound_relationships[predicate].each do |rel|
+            id_array << rel.gsub("info:fedora/", "")
+          end
+        end
+        query = self.class.outbound_named_relationship_query(relationship_name,id_array)
+      elsif inbound_relationship_names.include?(relationship_name)
+        query = self.class.inbound_named_relationship_query(pid,relationship_name)
+      end
+      query
+    end
+
     module ClassMethods
     
       # Allows for a relationship to be treated like any other attribute of a model class. You define
@@ -452,7 +499,10 @@ module ActiveFedora
       #  class AudioRecord < ActiveFedora::Base
       #
       #   has_relationship "oral_history", :has_part, :inbound=>true, :type=>OralHistory
+      #   # returns all similar audio
       #   has_relationship "similar_audio", :has_part, :type=>AudioRecord
+      #   #returns only similar audio with format wav
+      #   has_relationship "similar_audio_wav", :has_part, :query_params=>{:q=>"format_t"=>"wav"}
       #
       # The first two parameters are required:
       #   name: relationship name
@@ -461,6 +511,7 @@ module ActiveFedora
       #     possible parameters  
       #       :inbound => if true loads an external relationship via Solr (defaults to false)
       #       :type => The type of model to use when instantiated an object from the pid in this relationship (defaults to ActiveFedora::Base)
+      #       :query_params => Additional filters to be attached via a solr query (currently only :q implemented)
       #
       # If inbound is true it expects the relationship to be defined by another object's RELS-EXT
       # and to load that relationship from Solr.  Otherwise, if inbound is true the relationship is stored in
@@ -472,22 +523,24 @@ module ActiveFedora
       # For the oral_history relationship in the example above the following helper methods are created:
       #  oral_history: returns array of OralHistory objects that have this AudioRecord with predicate :has_part 
       #  oral_history_ids: Return array of pids for OralHistory objects that have this AudioRecord with predicate :has_part
+      #  oral_history_query: Return solr query that can be used to retrieve related objects as solr documents
       # 
       # For the outbound relationship "similar_audio" there are two additional methods to append and remove objects from that relationship
       # since it is managed internally:
       #  similar_audio: Return array of AudioRecord objects that have been added to similar_audio relationship
       #  similar_audio_ids:  Return array of AudioRecord object pids that have been added to similar_audio relationship
+      #  similar_audio_query: Return solr query that can be used to retrieve related objects as solr documents
       #  similar_audio_append: Add an AudioRecord object to the similar_audio relationship
       #  similar_audio_remove: Remove an AudioRecord from the similar_audio relationship
       def has_relationship(name, predicate, opts = {})
         opts = {:singular => nil, :inbound => false}.merge(opts)
         if opts[:inbound] == true
-          raise "Duplicate use of predicate for named inbound relationship not allowed" if named_predicate_exists_with_different_name?(:inbound,name,predicate)
+          #raise "Duplicate use of predicate for named inbound relationship not allowed" if named_predicate_exists_with_different_name?(:inbound,name,predicate)
           register_named_relationship(:inbound, name, predicate, opts)
           register_predicate(:inbound, predicate)
           create_inbound_relationship_finders(name, predicate, opts)
         else
-          raise "Duplicate use of predicate for named outbound relationship not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
+          #raise "Duplicate use of predicate for named outbound relationship not allowed" if named_predicate_exists_with_different_name?(:self,name,predicate)
           register_named_relationship(:self, name, predicate, opts)
           register_predicate(:self, predicate)
           create_named_relationship_methods(name)
@@ -562,6 +615,160 @@ module ActiveFedora
         opts.merge!({:predicate=>predicate})
         named_relationships_desc[subject][name] = opts
       end
+
+      # Returns a solr query for retrieving objects specified in an outbound relationship.
+      # This method is mostly used by internal method calls.
+      # It enables the use of query_params defined within a relationship to attach a query filter
+      # on top of just the predicate being used.  Because it is static it 
+      # needs the pids defined within RELS-EXT for this relationship to be passed in.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.named_relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "parts_query" for relationship "parts".  This
+      # method would only be called directly if you had something like an array of outbound pids
+      # already in something like a solr document for object that has these relationships.
+      # @param [String] The name of the relationship defined in the model
+      # @param [Array] An array of pids to include in the query
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipQueryParam < ActiveFedora::Base
+      #     #points to all parents linked via is_member_of
+      #     has_relationship "parents", :is_member_of
+      #     #returns only parents that have a level value set to "series"
+      #     has_relationship "series_parents", :is_member_of, :query_params=>{:q=>{"level_t"=>"series"}}
+      #   end
+      #   s = SampleAFObjRelationshipQueryParam.new
+      #   obj = ActiveFedora::Base.new
+      #   s.series_parents_append(obj)
+      #   s.series_parents_query 
+      #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+      #   SampleAFObjRelationshipQueryParam.outbound_named_relationship_query("series_parents",["id:changeme:13020"])
+      #   #=> "(id:changeme\\:13020 AND level_t:series)" 
+      def outbound_named_relationship_query(relationship_name,outbound_pids)
+        query = ActiveFedora::SolrService.construct_query_for_pids(outbound_pids)
+        subject = :self
+        if named_relationships_desc.has_key?(subject) && named_relationships_desc[subject].has_key?(relationship_name) && named_relationships_desc[subject][relationship_name].has_key?(:query_params)
+          query_params = format_query_params(named_relationships_desc[subject][relationship_name][:query_params])
+          if query_params[:q]
+            unless query.empty?
+              #substitute in the filter query for each pid so that it is applied to each in the query
+              query.sub!(/OR /,"AND #{query_params[:q]}) OR (")
+              #add opening parenthesis for first case
+              query = "(" + query 
+              #add AND filter case for last element as well since no 'OR' following it
+              query << " AND #{query_params[:q]})"
+            else
+              query = query_params[:q]
+            end
+          end
+        end
+        query
+      end
+
+      # Returns a solr query for retrieving objects specified in an inbound relationship.
+      # This method is mostly used by internal method calls.
+      # It enables the use of query_params defined within a relationship to attach a query filter
+      # on top of just the predicate being used.  Because it is static it 
+      # needs the pid of the object that has the inbound relationships passed in.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.named_relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "parts_query" for relationship "parts".  This
+      # method would only be called directly if you were working only with Solr and already
+      # had the pid for the object in something like a solr document.
+      # @param [String] The pid for the object that has these inbound relationships
+      # @param [String] The name of the relationship defined in the model
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipQueryParam < ActiveFedora::Base
+      #     #returns all parts
+      #     has_relationship "parts", :is_part_of, :inbound=>true
+      #     #returns only parts that have level to "series"
+      #     has_relationship "series_parts", :is_part_of, :inbound=>true, :query_params=>{:q=>{"level_t"=>"series"}}
+      #   end
+      #   s = SampleAFObjRelationshipQueryParam.new
+      #   s.pid 
+      #   #=> id:changeme:13020
+      #   s.series_parts_query
+      #   #=> "is_part_of_s:info\\:fedora/changeme\\:13021 AND level_t:series"
+      #   SampleAFObjRelationshipQueryParam.inbound_named_relationship_query(s.pid,"series_parts")
+      #   #=> "is_part_of_s:info\\:fedora/changeme\\:13021 AND level_t:series"
+      def inbound_named_relationship_query(pid,relationship_name)
+        query = ""
+        subject = :inbound
+        if named_relationships_desc.has_key?(subject) && named_relationships_desc[subject].has_key?(relationship_name)
+          predicate = named_relationships_desc[subject][relationship_name][:predicate]
+          internal_uri = "info:fedora/#{pid}"
+          escaped_uri = internal_uri.gsub(/(:)/, '\\:')
+          query = "#{predicate}_s:#{escaped_uri}" 
+          if named_relationships_desc.has_key?(subject) && named_relationships_desc[subject].has_key?(relationship_name) && named_relationships_desc[subject][relationship_name].has_key?(:query_params)
+            query_params = format_query_params(named_relationships_desc[subject][relationship_name][:query_params])
+            if query_params[:q]
+              query << " AND " unless query.empty?
+              query << query_params[:q]
+            end
+          end
+        end
+        query
+      end
+
+      # Returns a solr query for retrieving objects specified in a bidirectional relationship.
+      # This method is mostly used by internal method calls.
+      # It enables the use of query_params defined within a relationship to attach a query filter
+      # on top of just the predicate being used.  Because it is static it 
+      # needs the pids defined within RELS-EXT for the outbound relationship as well as the pid of the
+      # object for the inbound portion of the relationship.
+      # If you are calling this method directly to get the query you should use the 
+      # ActiveFedora::SemanticNode.named_relationship_query instead or use the helper method
+      # [relationship_name]_query, i.e. method "bi_parts_query" for relationship "bi_parts".  This
+      # method would only be called directly if you had something like an array of outbound pids
+      # already in something like a solr document for object that has these relationships.
+      # @param [String] The pid for the object that has these inbound relationships
+      # @param [String] The name of the relationship defined in the model
+      # @param [Array] An array of pids to include in the query
+      # @return [String]
+      # @example
+      #   Class SampleAFObjRelationshipQueryParam < ActiveFedora::Base
+      #     has_bidirectional_relationship "bi_series_parts", :has_part, :is_part_of, :query_params=>{:q=>{"level_t"=>"series"}}
+      #   end
+      #   s = SampleAFObjRelationshipQueryParam.new
+      #   obj = ActiveFedora::Base.new
+      #   s.bi_series_parts_append(obj)
+      #   s.pid
+      #   #=> "changeme:13025" 
+      #   obj.pid
+      #   #=> id:changeme:13026
+      #   s.bi_series_parts_query 
+      #   #=> "(id:changeme\\:13026 AND level_t:series) OR (is_part_of_s:info\\:fedora/changeme\\:13025 AND level_t:series)" 
+      #   SampleAFObjRelationshipQueryParam.bidirectional_named_relationship_query(s.pid,"series_parents",["id:changeme:13026"])
+      #   #=> "(id:changeme\\:13026 AND level_t:series) OR (is_part_of_s:info\\:fedora/changeme\\:13025 AND level_t:series)" 
+      def bidirectional_named_relationship_query(pid,relationship_name,outbound_pids)
+        outbound_named_relationship_query("#{relationship_name}_outbound",outbound_pids) + " OR (" + inbound_named_relationship_query(pid,"#{relationship_name}_inbound") + ")"
+      end
+
+      # This will transform and encode any query_params defined in a relationship method to properly escape special characters
+      # and format strings such as query string properly for a solr query
+      # @param [Hash] The has of expected query params (including at least :q)
+      # @return [String]
+      def format_query_params(query_params)
+        if query_params && query_params[:q]
+          add_query = ""
+          if query_params[:q].is_a? Hash
+            query_params[:q].keys.each_with_index do |key,index|
+              add_query << " AND " if index > 0
+              add_query << "#{key}:#{query_params[:q][key].gsub(/:/, '\\\\:')}"
+            end
+          elsif !query_params[:q].empty?
+            add_query = "#{query_params[:q]}"
+          end
+          query_params[:q] = add_query unless add_query.empty?
+          query_params
+        end
+      end
+
+      #Tests if the relationship name passed is in bidirectional
+      # @return [Boolean]
+      def is_bidirectional_relationship?(relationship_name)
+        named_relationships_desc[:self]["#{relationship_name}_outbound"] && named_relationships_desc[:inbound]["#{relationship_name}_inbound"] 
+      end
       
       # ** EXPERIMENTAL **
       #   
@@ -601,8 +808,8 @@ module ActiveFedora
         class_eval <<-END
         def #{name}(opts={})
           opts = {:rows=>25}.merge(opts)
-          escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
-          solr_result = SolrService.instance.conn.query("#{predicate}_s:\#{escaped_uri}", :rows=>opts[:rows])
+          query = self.class.inbound_named_relationship_query(self.pid,"#{name}")
+          solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
           if opts[:response_format] == :solr
             return solr_result
           else
@@ -625,8 +832,18 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_solr_docs
+          #{name}(:response_format => :solr)
+        end
+        def #{name}_query
+          named_relationship_query("#{name}")
+        end
         END
       end
+
+      def relationship_has_query_params?(subject, relationship_name)
+        named_relationships_desc.has_key?(subject) && named_relationships_desc[subject].has_key?(relationship_name) && named_relationships_desc[subject][relationship_name].has_key?(:query_params)
+      end
     
       def create_outbound_relationship_finders(name, predicate, opts = {})
         class_eval <<-END
@@ -637,13 +854,20 @@ module ActiveFedora
               id_array << rel.gsub("info:fedora/", "")
             end
           end
-          if opts[:response_format] == :id_array
+          
+          if opts[:response_format] == :id_array && !self.class.relationship_has_query_params?(:self,"#{name}")
             return id_array
           else
-            query = ActiveFedora::SolrService.construct_query_for_pids(id_array)
+            query = self.class.outbound_named_relationship_query("#{name}",id_array)
             solr_result = SolrService.instance.conn.query(query)
             if opts[:response_format] == :solr
               return solr_result
+            elsif opts[:response_format] == :id_array
+              id_array = []
+              solr_result.hits.each do |hit|
+                id_array << hit[SOLR_DOCUMENT_ID]
+              end
+              return id_array
             elsif opts[:response_format] == :load_from_solr || self.load_from_solr
               return ActiveFedora::SolrService.reify_solr_results(solr_result,{:load_from_solr=>true})
             else
@@ -657,9 +881,15 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_solr_docs
+          #{name}(:response_format => :solr)
+        end
+        def #{name}_query
+          named_relationship_query("#{name}")
+        end
         END
       end
-      
+
       # Generates relationship finders for predicates that point in both directions
       # and registers predicate relationships for each direction.
       #
@@ -680,12 +910,15 @@ module ActiveFedora
         def #{name}(opts={})
           opts = {:rows=>25}.merge(opts)
           if opts[:response_format] == :solr || opts[:response_format] == :load_from_solr
-            escaped_uri = self.internal_uri.gsub(/(:)/, '\\:')
-            query = "#{inbound_predicate}_s:\#{escaped_uri}"
-            
-            outbound_id_array = #{outbound_method_name}(:response_format=>:id_array)
-            query = query + " OR " + ActiveFedora::SolrService.construct_query_for_pids(outbound_id_array)
-            
+            outbound_id_array = []
+            predicate = outbound_named_relationship_predicates["#{name}_outbound"]
+            if !outbound_relationships[predicate].nil? 
+              outbound_relationships[predicate].each do |rel|
+                outbound_id_array << rel.gsub("info:fedora/", "")
+              end
+            end
+            #outbound_id_array = #{outbound_method_name}(:response_format=>:id_array)
+            query = self.class.bidirectional_named_relationship_query(self.pid,"#{name}",outbound_id_array)
             solr_result = SolrService.instance.conn.query(query, :rows=>opts[:rows])
             
             if opts[:response_format] == :solr
@@ -706,6 +939,12 @@ module ActiveFedora
         def #{name}_from_solr
           #{name}(:response_format => :load_from_solr)
         end
+        def #{name}_solr_docs
+          #{name}(:response_format => :solr)
+        end
+        def #{name}_query
+          named_relationship_query("#{name}")
+        end
         END
       end
     

data/lib/active_fedora/version.rb

@@ -1,3 +1,3 @@
 module ActiveFedora
-    VERSION = "2.3.0"
+    VERSION = "2.3.1"
 end

data/spec/fixtures/rails_root/config/fedora.yml

@@ -1,13 +1,13 @@
 development:
   fedora:
-    url: http://fedoraAdmin:fedoraAdmin@testhost.com:8983/fedora
+    url: http://fedoraAdmin:fedoraAdmin@localhost:8983/fedora
   solr:
-    url: http://testhost.com:8983/solr/development
+    url: http://localhost:8983/solr/development
 test:
   fedora:
-    url: http://fedoraAdmin:fedoraAdmin@testhost.com:8983/fedora
+    url: http://fedoraAdmin:fedoraAdmin@localhost:8983/fedora
   solr:
-    url: http://testhost.com:8983/solr/development
+    url: http://localhost:8983/solr/development
 production:
   fedora:
     url: http://fedoraAdmin:fedoraAdmin@testhost.com:8080/fedora

data/spec/integration/nokogiri_datastream_spec.rb

@@ -20,7 +20,8 @@ describe ActiveFedora::NokogiriDatastream do
         m.field 'collection', :string
       end
     end
-
+    
+    RAILS_ENV='development'
     @pid = "hydrangea:fixture_mods_article1"
     @test_solr_object = HydrangeaArticle2.load_instance_from_solr(@pid)
     @test_object = HydrangeaArticle2.load_instance(@pid)

data/spec/integration/semantic_node_spec.rb

@@ -13,6 +13,15 @@ describe ActiveFedora::SemanticNode do
     class SNSpecModel < ActiveFedora::Base
       has_relationship("parts", :is_part_of, :inbound => true)
       has_relationship("containers", :is_member_of)
+      has_bidirectional_relationship("bi_containers", :is_member_of, :has_member)
+    end
+    class SpecNodeQueryParam < ActiveFedora::Base
+      has_relationship("parts", :is_part_of, :inbound => true)
+      has_relationship("special_parts", :is_part_of, :inbound => true, :query_params=>{:q=>{"has_model_s"=>"info:fedora/SpecialPart"}})
+      has_relationship("containers", :is_member_of)
+      has_relationship("special_containers", :is_member_of, :query_params=>{:q=>{"has_model_s"=>"info:fedora/SpecialContainer"}})
+      has_bidirectional_relationship("bi_containers", :is_member_of, :has_member)
+      has_bidirectional_relationship("bi_special_containers", :is_member_of, :has_member, :query_params=>{:q=>{"has_model_s"=>"info:fedora/SpecialContainer"}})
     end
     
     @test_object = SNSpecModel.new
@@ -25,24 +34,89 @@ describe ActiveFedora::SemanticNode do
     @part2.add_relationship(:is_part_of, @test_object)
     @part2.save
     
-    
     @container1 = ActiveFedora::Base.new()
     @container1.save
     @container2 = ActiveFedora::Base.new()    
     @container2.save
+    @container3 = ActiveFedora::Base.new()    
+    @container3.save
     
     @test_object.add_relationship(:is_member_of, @container1)
     @test_object.add_relationship(:is_member_of, @container2)
     @test_object.save
+
+    @special_container = ActiveFedora::Base.new()
+    @special_container.add_relationship(:has_model,"SpecialContainer")
+    @special_container.save
+
+    #even though adding container3 and special container, it should only include special_container when returning via named finder methods
+    #also should only return special part similarly
+    @test_object_query = SpecNodeQueryParam.new
+    @test_object_query.add_relationship(:is_member_of, @container3)
+    @test_object_query.add_relationship(:is_member_of, @special_container)
+    @test_object_query.save
+
+    @special_container2 = ActiveFedora::Base.new()
+    @special_container2.add_relationship(:has_model,"SpecialContainer")
+    @special_container2.add_relationship(:has_member,@test_object_query.pid)
+    @special_container2.save
+
+    @part3 = ActiveFedora::Base.new()
+    @part3.add_relationship(:is_part_of, @test_object_query)
+    @part3.save
+
+    @special_part = ActiveFedora::Base.new()
+    @special_part.add_relationship(:has_model,"SpecialPart")
+    @special_part.add_relationship(:is_part_of, @test_object_query)
+    @special_part.save
+   
   end
   
   after(:all) do
+    begin
     @part1.delete 
+    rescue
+    end
+    begin
     @part2.delete
+    rescue
+    end
+    begin
+    @part3.delete
+    rescue
+    end
+    begin
     @container1.delete
+    rescue
+    end
+    begin
     @container2.delete
+    rescue
+    end
+    begin
+    @container3.delete
+    rescue
+    end
+    begin
     @test_object.delete
-    
+    rescue
+    end
+    begin
+    @test_object_query.delete
+    rescue
+    end
+    begin
+    @special_part.delete
+    rescue
+    end
+    begin
+    @special_container.delete
+    rescue
+    end
+    begin
+    @special_container2.delete
+    rescue
+    end
     Object.send(:remove_const, :SNSpecModel)
 
   end
@@ -74,6 +148,73 @@ describe ActiveFedora::SemanticNode do
         id.should satisfy {|id| id == @part1.pid || @part2.pid}
       end  
     end
+    it "should return an array of Base objects with some filtered out if using query params" do
+      @test_object_query.special_parts_ids.should == [@special_part.pid]
+    end
+
+    it "should return an array of all Base objects with relationship if not using query params" do
+      @test_object_query.parts_ids.size.should == 2
+      @test_object_query.parts_ids.include?(@special_part.pid).should == true
+      @test_object_query.parts_ids.include?(@part3.pid).should == true
+    end
+
+    it "should return a solr query for an inbound relationship" do
+      @test_object_query.special_parts_query.should == "#{@test_object_query.named_relationship_predicates[:inbound]['special_parts']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialPart"
+    end
+  end
+
+  describe "inbound named relationship query" do
+    it "should return a properly formatted query for a relationship that has a query param defined" do
+      SpecNodeQueryParam.inbound_named_relationship_query(@test_object_query.pid,"special_parts").should == "#{@test_object_query.named_relationship_predicates[:inbound]['special_parts']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialPart"
+    end
+
+    it "should return a properly formatted query for a relationship that does not have a query param defined" do
+      SpecNodeQueryParam.inbound_named_relationship_query(@test_object_query.pid,"parts").should == "is_part_of_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')}"
+    end
+  end
+
+  describe "outbound named relationship query" do
+    it "should return a properly formatted query for a relationship that has a query param defined" do
+      expected_string = ""
+      @test_object_query.containers_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      SpecNodeQueryParam.outbound_named_relationship_query("special_containers",@test_object_query.containers_ids).should == expected_string
+    end
+
+    it "should return a properly formatted query for a relationship that does not have a query param defined" do
+      expected_string = ""
+      @test_object_query.containers_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "id:" + id.gsub(/(:)/, '\\:')
+      end
+      SpecNodeQueryParam.outbound_named_relationship_query("containers",@test_object_query.containers_ids).should == expected_string
+    end
+  end
+
+  describe "bidirectional named relationship query" do
+    it "should return a properly formatted query for a relationship that has a query param defined" do
+      expected_string = ""
+      @test_object_query.bi_containers_outbound_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      expected_string << " OR "
+      expected_string << "(#{@test_object_query.named_relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialContainer)"
+      SpecNodeQueryParam.bidirectional_named_relationship_query(@test_object_query.pid,"bi_special_containers",@test_object_query.bi_containers_outbound_ids).should == expected_string
+    end
+
+    it "should return a properly formatted query for a relationship that does not have a query param defined" do
+      expected_string = ""
+      @test_object_query.bi_containers_outbound_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "id:" + id.gsub(/(:)/, '\\:')
+      end
+      expected_string << " OR "
+      expected_string << "(#{@test_object_query.named_relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')})"
+      SpecNodeQueryParam.bidirectional_named_relationship_query(@test_object_query.pid,"bi_containers",@test_object_query.bi_containers_outbound_ids).should == expected_string
+    end
   end
   
   describe "outbound relationship finders" do
@@ -90,5 +231,121 @@ describe ActiveFedora::SemanticNode do
         id.should satisfy {|id| id == @container1.pid || @container2.pid}
       end  
     end
+
+    it "should return an array of Base objects with some filtered out if using query params" do
+      @test_object_query.special_containers_ids.size.should == 1
+      @test_object_query.special_containers_ids.include?(@container3.pid).should == false
+      @test_object_query.special_containers_ids.include?(@special_container.pid).should == true
+    end
+
+    it "should return an array of all Base objects with relationship if not using query params" do
+      @test_object_query.containers_ids.size.should == 2
+      @test_object_query.containers_ids.include?(@special_container2.pid).should == false
+      @test_object_query.containers_ids.include?(@special_container.pid).should == true
+      @test_object_query.containers_ids.include?(@container3.pid).should == true
+    end
+
+    it "should return a solr query for an outbound relationship" do
+      expected_string = ""
+      @test_object_query.containers_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      @test_object_query.special_containers_query.should == expected_string
+    end 
   end  
+
+  describe "bidirectional relationship finders" do
+    it "should return an array of Base objects" do
+      containers = @test_object.bi_containers
+      containers.length.should > 0
+      containers.each do |container|
+        container.should be_kind_of(ActiveFedora::Base)
+      end  
+    end
+    it "_ids should return an array of pids" do
+      ids = @test_object.bi_containers_ids
+      ids.size.should == 2
+      ids.each do |id|
+        id.should satisfy {|id| id == @container1.pid || @container2.pid}
+      end  
+    end
+
+    it "should return an array of Base objects with some filtered out if using query params" do
+      ids = @test_object_query.bi_special_containers_ids
+      ids.size.should == 2
+      ids.each do |id|
+        id.should satisfy {|id| id == @special_container.pid || @special_container2.pid}
+      end  
+    end
+
+    it "should return an array of all Base objects with relationship if not using query params" do
+      ids = @test_object_query.bi_containers_ids
+      ids.size.should == 3
+      ids.each do |id|
+        id.should satisfy {|id| id == @special_container.pid || @special_container2.pid || @container3.pid}
+      end  
+    end
+
+    it "should return a solr query for a bidirectional relationship" do
+      expected_string = ""
+      @test_object_query.bi_containers_outbound_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      expected_string << " OR "
+      expected_string << "(#{@test_object_query.named_relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialContainer)"
+      @test_object_query.bi_special_containers_query.should == expected_string
+    end
+  end 
+
+  describe "named_relationship_query" do
+    it "should return correct query for a bidirectional relationship with query params" do
+      expected_string = ""
+      @test_object_query.bi_containers_outbound_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      expected_string << " OR "
+      expected_string << "(#{@test_object_query.named_relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialContainer)"
+      @test_object_query.named_relationship_query("bi_special_containers").should == expected_string
+    end
+  
+    it "should return correct query for a bidirectional relationship without query params" do
+      expected_string = ""
+      @test_object_query.bi_containers_outbound_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "id:" + id.gsub(/(:)/, '\\:')
+      end
+      expected_string << " OR "
+      expected_string << "(#{@test_object_query.named_relationship_predicates[:inbound]['bi_special_containers_inbound']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')})"
+      @test_object_query.named_relationship_query("bi_containers").should == expected_string
+    end
+
+    it "should return a properly formatted query for an outbound relationship that has a query param defined" do
+      expected_string = ""
+      @test_object_query.containers_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "(id:" + id.gsub(/(:)/, '\\:') + " AND has_model_s:info\\:fedora/SpecialContainer)"
+      end
+      @test_object_query.named_relationship_query("special_containers").should == expected_string
+    end
+
+    it "should return a properly formatted query for an outbound relationship that does not have a query param defined" do
+      expected_string = ""
+      @test_object_query.containers_ids.each_with_index do |id,index|
+        expected_string << " OR " if index > 0
+        expected_string << "id:" + id.gsub(/(:)/, '\\:')
+      end
+      @test_object_query.named_relationship_query("containers").should == expected_string
+    end
+
+    it "should return a properly formatted query for an inbound relationship that has a query param defined" do
+      @test_object_query.named_relationship_query("special_parts").should == "#{@test_object_query.named_relationship_predicates[:inbound]['special_parts']}_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')} AND has_model_s:info\\:fedora/SpecialPart"
+    end
+
+    it "should return a properly formatted query for an inbound relationship that does not have a query param defined" do
+      @test_object_query.named_relationship_query("parts").should == "is_part_of_s:#{@test_object_query.internal_uri.gsub(/(:)/, '\\:')}"
+    end
+  end 
 end