om 1.6.1 → 1.7.0.rc1

data/lib/om/xml/term_value_operators.rb

@@ -122,6 +122,7 @@ module OM::XML::TermValueOperators
   # @param [Array -- (OM term pointer array) OR String -- (like what you would pass into Nokogiri::XML::Builder.new)] template for building the new xml.  Use the syntax that Nokogiri::XML::Builder uses.
   # @return [Nokogiri::XML::Node] the parent_node with new chldren inserted into it
   def insert_from_template(parent_node, new_values, template)
+    ng_xml_will_change!
     # If template is a string, use it as the template, otherwise use it as arguments to xml_builder_template
     unless template.instance_of?(String)
       template_args = Array(template)
@@ -202,20 +203,26 @@ module OM::XML::TermValueOperators
   end
   
   def term_value_update(node_select,node_index,new_value,opts={})
+    ng_xml_will_change!
     # template = opts.fetch(:template,nil)
     
     node = find_by_terms_and_value(*node_select)[node_index]
-    if new_value == "" || new_value == :delete
+    if delete_on_update?(node, new_value)
       node.remove
     else
       node.content = new_value
     end
   end
+
+  def delete_on_update?(node, new_value)
+    new_value == "" || new_value == :delete
+  end
   
   # def term_value_set(term_ref, query_opts, node_index, new_value)
   # end
   
   def term_value_delete(opts={})
+    ng_xml_will_change!
     parent_select = Array( opts[:parent_select] )
     parent_index = opts[:parent_index]
     child_index = opts[:child_index]

data/lib/om/xml/validation.rb

@@ -1,4 +1,5 @@
 module OM::XML::Validation
+  extend ActiveSupport::Concern
     
   # Class Methods -- These methods will be available on classes that include this Module 
   
@@ -52,12 +53,8 @@ module OM::XML::Validation
   
   # Instance Methods -- These methods will be available on instances of classes that include this module
   
-  def self.included(klass)
-    klass.extend(ClassMethods)
-  end
-  
   def validate
     self.class.validate(self)
   end
     
-end
+end

data/om.gemspec

@@ -12,10 +12,13 @@ Gem::Specification.new do |s|
   s.summary     = %q{OM (Opinionated Metadata): A library to help you tame sprawling XML schemas like MODS.}
   s.description = %q{OM (Opinionated Metadata): A library to help you tame sprawling XML schemas like MODS.  Wraps Nokogiri documents in objects with miscellaneous helper methods for doing things like retrieve generated xpath queries or look up properties based on a simplified DSL}
 
+  s.add_dependency 'activesupport'
+  s.add_dependency 'activemodel'
   s.add_dependency('nokogiri', ">= 1.4.2")
   s.add_dependency('mediashelf-loggable')
   s.add_development_dependency "rspec", "~> 2.0"
   s.add_development_dependency "rake"
+  s.add_development_dependency "awesome_print"
   s.add_development_dependency "mocha", ">= 0.9.8"
   s.add_development_dependency "equivalent-xml", ">= 0.2.4"
 

data/spec/integration/serialization_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "element values" do
+  before(:all) do
+    class ElementValueTerminology
+      include OM::XML::Document
+
+      set_terminology do |t|
+        t.root(:path => "outer", :xmlns => nil)
+        t.my_date(:type=>:date)
+        t.my_int(:type=>:integer)
+      end
+    end
+  end
+
+  subject do
+    ElementValueTerminology.from_xml <<-EOF
+<outer outerId="hypatia:outer" type="outer type">
+  <my_date>2012-10-30</my_date>
+  <my_int>7</my_int>
+</outer>
+EOF
+end
+
+  describe "Reading from xml" do
+    it "should handle date" do
+      subject.my_date.should == [Date.parse('2012-10-30')]
+    end
+    it "should handle ints" do
+      subject.my_int.should == [7]
+    end
+  end
+  describe "Writing to xml" do
+    it "should handle date" do
+      subject.my_date = [Date.parse('2012-09-22')]
+      subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+       <outer outerId="hypatia:outer" type="outer type">
+         <my_date>2012-09-22</my_date>
+         <my_int>7</my_int>
+       </outer>'
+    end
+    it "should handle ints" do
+      subject.my_int = [9]
+      subject.to_xml.should be_equivalent_to '<?xml version="1.0"?>
+       <outer outerId="hypatia:outer" type="outer type">
+         <my_date>2012-10-30</my_date>
+         <my_int>9</my_int>
+       </outer>'
+    end
+  end
+
+end
+

data/spec/unit/container_spec.rb

@@ -8,21 +8,25 @@ describe "OM::XML::Container" do
     end
   end
   
-  before(:each) do
-    @container = ContainerTest.from_xml("<foo><bar>1</bar></foo>")
-  end
-  
+  subject {
+    ContainerTest.from_xml("<foo><bar>1</bar></foo>")
+  }
+
   it "should add .ng_xml accessor" do
-    @container.should respond_to(:ng_xml)
-    @container.should respond_to(:ng_xml=)    
+    subject.should respond_to(:ng_xml)
+    subject.should respond_to(:ng_xml=)    
+  end
+
+  it "should initialize" do
+    ContainerTest.new.ng_xml.should be_a_kind_of Nokogiri::XML::Document
   end
   
   describe "new" do
     it "should populate ng_xml with an instance of Nokogiri::XML::Document" do
-      @container.ng_xml.class.should == Nokogiri::XML::Document
+      subject.ng_xml.class.should == Nokogiri::XML::Document
     end
   end
-  
+
   describe "#from_xml" do
     it "should accept a String, parse it and store it in .ng_xml" do
       Nokogiri::XML::Document.expects(:parse).returns("parsed xml")
@@ -44,20 +48,20 @@ describe "OM::XML::Container" do
   
   describe ".to_xml" do
     it  "should call .ng_xml.to_xml" do
-      @container.ng_xml.expects(:to_xml).returns("ng xml")
-      @container.to_xml.should == "ng xml"
+      subject.ng_xml.expects(:to_xml).returns("ng xml")
+      subject.to_xml.should == "ng xml"
     end
     
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (mocked test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
       mock_new_node = mock("new node")
-      doc.root.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
-      result = @container.to_xml(doc)
+      doc.root.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
+      result = subject.to_xml(doc)
     end
     
     it 'should accept an optional Nokogiri::XML Document as an argument and insert its fields into that (functional test)' do
       doc = Nokogiri::XML::Document.parse("<test_xml/>")
-      @container.to_xml(doc).should == "<?xml version=\"1.0\"?>\n<test_xml>\n  <foo>\n    <bar>1</bar>\n  </foo>\n</test_xml>\n"
+      subject.to_xml(doc).should == "<?xml version=\"1.0\"?>\n<test_xml>\n  <foo>\n    <bar>1</bar>\n  </foo>\n</test_xml>\n"
     end
     
     it 'should add to root of Nokogiri::XML::Documents, but add directly to the elements if a Nokogiri::XML::Node is passed in' do
@@ -66,10 +70,10 @@ describe "OM::XML::Container" do
       
       doc = Nokogiri::XML::Document.parse("<test_document/>")
       el = Nokogiri::XML::Node.new("test_element", Nokogiri::XML::Document.new)
-      doc.root.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
-      el.expects(:add_child).with(@container.ng_xml.root).returns(mock_new_node)
-      @container.to_xml(doc).should 
-      @container.to_xml(el)
+      doc.root.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
+      el.expects(:add_child).with(subject.ng_xml.root).returns(mock_new_node)
+      subject.to_xml(doc).should 
+      subject.to_xml(el)
     end
   end
   

data/spec/unit/dynamic_node_spec.rb

@@ -132,11 +132,14 @@ describe "OM::XML::DynamicNode" do
       end
 
       it "should append nodes at the specified index if possible, setting dirty to true if the object responds to dirty" do
+        # backwards-compatible stuff..
         @article.stubs(:respond_to?).with(:dirty=).returns(true)
-        @article.expects(:dirty=).with(true).twice
+        @article.expects(:dirty=).with(true).at_least(2)
+
         @article.journal.title_info = ["all", "for", "the"]
         @article.journal.title_info(3, 'glory')
         @article.term_values(:journal, :title_info).should == ["all", "for", "the", "glory"]
+        @article.should be_changed
       end
     
     end

data/spec/unit/nokogiri_sanity_spec.rb

@@ -28,6 +28,7 @@ describe "OM::XML::TermValueOperators" do
       test_args = {[{:person=>0}, :first_name]=>{"0"=>"Replacement FirstName"}}
       @article.update_values(test_args)
       @article.term_values({:person=>0}, :first_name).should == ["Replacement FirstName"]
+      @article.should be_changed
     end
     
     it "should update the xml according to the find_by_terms_and_values in the given hash" do
@@ -39,6 +40,7 @@ describe "OM::XML::TermValueOperators" do
       terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_update_hash)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, "person_1_last_name"=>{"0"=>"Andronicus"},"person_1_first_name"=>{"0"=>"Titus"}, "person_1_role"=>{"0"=>"otherrole1","1"=>"otherrole2"}}
+      @article.should be_changed
     end
     
     it "should work when you re-run the command" do
@@ -66,6 +68,7 @@ describe "OM::XML::TermValueOperators" do
       terms_update_hash = {[{":person"=>"0"}, "affiliation"]=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, [{:person=>1}, :last_name]=>"Andronicus", [{"person"=>"1"},:first_name]=>["Titus"],[{:person=>1},:role]=>["otherrole1","otherrole2"] }
       result = @article.update_values(terms_update_hash)
       result.should == {"person_0_affiliation"=>{"0"=>"affiliation1", "1"=>"affiliation2", "2"=>"affiliation3"}, "person_1_last_name"=>{"0"=>"Andronicus"},"person_1_first_name"=>{"0"=>"Titus"}, "person_1_role"=>{"0"=>"otherrole1","1"=>"otherrole2"}}
+      @article.should be_changed
     end
   end
   

data/spec/unit/term_spec.rb

@@ -1,204 +1,243 @@
 require 'spec_helper'
 
-describe "OM::XML::Term" do
-
-  before(:each) do
-    @test_name_part = OM::XML::Term.new(:namePart, {}).generate_xpath_queries!
-    @test_volume = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
-    @test_date = OM::XML::Term.new(:namePart, :attributes=>{:type=> "date"})
-    @test_person = OM::XML::Term.new(:namePart, :attributes=>{:type=> :none})
-    @test_affiliation = OM::XML::Term.new(:affiliation)
-    @test_role_code = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
-    @test_type = OM::XML::Term.new(:class)
-  end
-
-  describe '#new' do
-    it "should set path from mapper name if no path is provided" do
-      @test_name_part.path.should == "namePart"
-    end
-    it "should populate the xpath values if no options are provided" do
-      local_mapping = OM::XML::Term.new(:namePart)
-      local_mapping.xpath_relative.should be_nil
-      local_mapping.xpath.should be_nil
-      local_mapping.xpath_constrained.should be_nil
+describe OM::XML::Term do
+  describe "without a type" do
+    subject { OM::XML::Term.new(:test_term) }
+    its (:type) { should == :string }
+  end
+  describe "when type is specified" do
+    subject { OM::XML::Term.new(:test_term, :type=>:date)}
+    its (:type) { should == :date }
+  end
+
+  describe "a big test" do
+    before(:each) do
+      @test_name_part = OM::XML::Term.new(:namePart, {}).generate_xpath_queries!
+      @test_volume = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+      @test_date = OM::XML::Term.new(:namePart, :attributes=>{:type=> "date"})
+      @test_person = OM::XML::Term.new(:namePart, :attributes=>{:type=> :none})
+      @test_affiliation = OM::XML::Term.new(:affiliation)
+      @test_role_code = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
+      @test_type = OM::XML::Term.new(:class)
+    end
+
+    describe '#new' do
+      it "should set path from mapper name if no path is provided" do
+        @test_name_part.path.should == "namePart"
+      end
+      it "should populate the xpath values if no options are provided" do
+        local_mapping = OM::XML::Term.new(:namePart)
+        local_mapping.xpath_relative.should be_nil
+        local_mapping.xpath.should be_nil
+        local_mapping.xpath_constrained.should be_nil
+      end
     end
-  end
 
-  describe 'inner_xml' do
-    it "should be a kind of Nokogiri::XML::Node" do
-      pending
-      @test_mapping.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+    describe 'inner_xml' do
+      it "should be a kind of Nokogiri::XML::Node" do
+        pending
+        @test_mapping.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+      end
     end
-  end
 
-  describe '#from_node' do
-    it "should create a mapper from a nokogiri node" do
-      pending "probably should do this in the Builder"
-      ng_builder = Nokogiri::XML::Builder.new do |xml|
-        xml.mapper(:name=>"person", :path=>"name") {
-          xml.attribute(:name=>"type", :value=>"personal")
-          xml.mapper(:name=>"first_name", :path=>"namePart") {
-            xml.attribute(:name=>"type", :value=>"given")
-            xml.attribute(:name=>"another_attribute", :value=>"myval")
+    describe '#from_node' do
+      it "should create a mapper from a nokogiri node" do
+        pending "probably should do this in the Builder"
+        ng_builder = Nokogiri::XML::Builder.new do |xml|
+          xml.mapper(:name=>"person", :path=>"name") {
+            xml.attribute(:name=>"type", :value=>"personal")
+            xml.mapper(:name=>"first_name", :path=>"namePart") {
+              xml.attribute(:name=>"type", :value=>"given")
+              xml.attribute(:name=>"another_attribute", :value=>"myval")
+            }
           }
-        }
+        end
+        # node = Nokogiri::XML::Document.parse( '<mapper name="first_name" path="namePart"><attribute name="type" value="given"/><attribute name="another_attribute" value="myval"/></mapper>' ).root
+        node = ng_builder.doc.root
+        mapper = OM::XML::Term.from_node(node)
+        mapper.name.should == :person
+        mapper.path.should == "name"
+        mapper.attributes.should == {:type=>"personal"}
+        mapper.internal_xml.should == node
+
+        child = mapper.children[:first_name]
+
+        child.name.should == :first_name
+        child.path.should == "namePart"
+        child.attributes.should == {:type=>"given", :another_attribute=>"myval"}
+        child.internal_xml.should == node.xpath("./mapper").first
       end
-      # node = Nokogiri::XML::Document.parse( '<mapper name="first_name" path="namePart"><attribute name="type" value="given"/><attribute name="another_attribute" value="myval"/></mapper>' ).root
-      node = ng_builder.doc.root
-      mapper = OM::XML::Term.from_node(node)
-      mapper.name.should == :person
-      mapper.path.should == "name"
-      mapper.attributes.should == {:type=>"personal"}
-      mapper.internal_xml.should == node
-
-      child = mapper.children[:first_name]
-
-      child.name.should == :first_name
-      child.path.should == "namePart"
-      child.attributes.should == {:type=>"given", :another_attribute=>"myval"}
-      child.internal_xml.should == node.xpath("./mapper").first
     end
-  end
 
-  describe ".label" do
-    it "should default to the mapper name with underscores converted to spaces"
-  end
+    describe ".label" do
+      it "should default to the mapper name with underscores converted to spaces"
+    end
 
-  describe ".retrieve_term" do
-    it "should crawl down into mapper children to find the desired term" do
-      mock_role = mock("mapper", :children =>{:text=>"the target"})
-      mock_conference = mock("mapper", :children =>{:role=>mock_role})
-      @test_name_part.expects(:children).returns({:conference=>mock_conference})
-      @test_name_part.retrieve_term(:conference, :role, :text).should == "the target"
+    describe ".retrieve_term" do
+      it "should crawl down into mapper children to find the desired term" do
+        mock_role = mock("mapper", :children =>{:text=>"the target"})
+        mock_conference = mock("mapper", :children =>{:role=>mock_role})
+        @test_name_part.expects(:children).returns({:conference=>mock_conference})
+        @test_name_part.retrieve_term(:conference, :role, :text).should == "the target"
+      end
+      it "should return an empty hash if no term can be found" do
+        @test_name_part.retrieve_term(:journal, :issue, :end_page).should == nil
+      end
     end
-    it "should return an empty hash if no term can be found" do
-      @test_name_part.retrieve_term(:journal, :issue, :end_page).should == nil
+
+    describe 'inner_xml' do
+      it "should be a kind of Nokogiri::XML::Node" do
+        pending
+        @test_name_part.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+      end
     end
-  end
 
-  describe 'inner_xml' do
-    it "should be a kind of Nokogiri::XML::Node" do
-      pending
-      @test_name_part.inner_xml.should be_kind_of(Nokogiri::XML::Node)
+    describe "getters/setters" do
+      it "should set the corresponding .settings value and return the current value" do
+        # :index_as is a special case
+        [:path, :required, :data_type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |method_name|
+          @test_name_part.send(method_name.to_s+"=", "#{method_name.to_s}foo").should == "#{method_name.to_s}foo"
+          @test_name_part.send(method_name).should == "#{method_name.to_s}foo"
+        end
+      end
     end
-  end
 
-  describe "getters/setters" do
-    it "should set the corresponding .settings value and return the current value" do
-      [:path, :index_as, :required, :data_type, :variant_of, :path, :attributes, :default_content_path, :namespace_prefix].each do |method_name|
-        @test_name_part.send(method_name.to_s+"=", "#{method_name.to_s}foo").should == "#{method_name.to_s}foo"
-        @test_name_part.send(method_name).should == "#{method_name.to_s}foo"
+    describe "OM terminology should accept a symbol as a value to :index_as" do
+      subject {
+        class TestTerminology
+          include OM::XML::Document
+          
+          set_terminology do |t|
+            t.as_array :index_as => [:not_searchable]
+            t.as_symbol :index_as => :not_searchable
+          end
+        end
+
+      TestTerminology
+      }
+
+      it "should accept an array as an :index_as value" do
+        subject.terminology.terms[:as_array].index_as.should be_a_kind_of(Array)
+        subject.terminology.terms[:as_array].index_as.should == [:not_searchable]
+      end
+      it "should accept a plain symbol as a value to :index_as" do
+        subject.terminology.terms[:as_symbol].index_as.should be_a_kind_of(Array)
+        subject.terminology.terms[:as_symbol].index_as.should == [:not_searchable]
       end
     end
-  end
-  it "should have a .terminology attribute accessor" do
-    @test_volume.should respond_to :terminology
-    @test_volume.should respond_to :terminology=
-  end
-  describe ".ancestors" do
-    it "should return an array of Terms that are the ancestors of the current object, ordered from the top/root of the hierarchy" do
-      @test_volume.set_parent(@test_name_part)
-      @test_volume.ancestors.should == [@test_name_part]
+    it "should have a .terminology attribute accessor" do
+      @test_volume.should respond_to :terminology
+      @test_volume.should respond_to :terminology=
     end
-  end
-  describe ".parent" do
-    it "should retrieve the immediate parent of the given object from the ancestors array" do
-      # @test_name_part.expects(:ancestors).returns(["ancestor1","ancestor2","ancestor3"])
-      @test_name_part.ancestors = ["ancestor1","ancestor2","ancestor3"]
-      @test_name_part.parent.should == "ancestor3"
+    describe ".ancestors" do
+      it "should return an array of Terms that are the ancestors of the current object, ordered from the top/root of the hierarchy" do
+        @test_volume.set_parent(@test_name_part)
+        @test_volume.ancestors.should == [@test_name_part]
+      end
     end
-  end
-  describe ".children" do
-    it "should return a hash of Terms that are the children of the current object, indexed by name" do
-      @test_volume.add_child(@test_name_part)
-      @test_volume.children[@test_name_part.name].should == @test_name_part
+    describe ".parent" do
+      it "should retrieve the immediate parent of the given object from the ancestors array" do
+        # @test_name_part.expects(:ancestors).returns(["ancestor1","ancestor2","ancestor3"])
+        @test_name_part.ancestors = ["ancestor1","ancestor2","ancestor3"]
+        @test_name_part.parent.should == "ancestor3"
+      end
     end
-  end
-  describe ".retrieve_child" do
-    it "should fetch the child identified by the given name" do
-      @test_volume.add_child(@test_name_part)
-      @test_volume.retrieve_child(@test_name_part.name).should == @test_volume.children[@test_name_part.name]
+    describe ".children" do
+      it "should return a hash of Terms that are the children of the current object, indexed by name" do
+        @test_volume.add_child(@test_name_part)
+        @test_volume.children[@test_name_part.name].should == @test_name_part
+      end
     end
-  end
-  describe ".set_parent" do
-    it "should insert the mapper into the given parent" do
-      @test_name_part.set_parent(@test_volume)
-      @test_name_part.ancestors.should include(@test_volume)
-      @test_volume.children[@test_name_part.name].should == @test_name_part
+    describe ".retrieve_child" do
+      it "should fetch the child identified by the given name" do
+        @test_volume.add_child(@test_name_part)
+        @test_volume.retrieve_child(@test_name_part.name).should == @test_volume.children[@test_name_part.name]
+      end
     end
-  end
-  describe ".add_child" do
-    it "should insert the given mapper into the current mappers children" do
-      @test_volume.add_child(@test_name_part)
-      @test_volume.children[@test_name_part.name].should == @test_name_part
-      @test_name_part.ancestors.should include(@test_volume)
+    describe ".set_parent" do
+      it "should insert the mapper into the given parent" do
+        @test_name_part.set_parent(@test_volume)
+        @test_name_part.ancestors.should include(@test_volume)
+        @test_volume.children[@test_name_part.name].should == @test_name_part
+      end
     end
-  end
-
-  describe "generate_xpath_queries!" do
-    it "should return the current object" do
-      @test_name_part.generate_xpath_queries!.should == @test_name_part
+    describe ".add_child" do
+      it "should insert the given mapper into the current mappers children" do
+        @test_volume.add_child(@test_name_part)
+        @test_volume.children[@test_name_part.name].should == @test_name_part
+        @test_name_part.ancestors.should include(@test_volume)
+      end
     end
-    it "should regenerate the xpath values" do
-      @test_volume.xpath_relative.should be_nil
-      @test_volume.xpath.should be_nil
-      @test_volume.xpath_constrained.should be_nil
 
-      @test_volume.generate_xpath_queries!.should == @test_volume
+    describe "generate_xpath_queries!" do
+      it "should return the current object" do
+        @test_name_part.generate_xpath_queries!.should == @test_name_part
+      end
+      it "should regenerate the xpath values" do
+        @test_volume.xpath_relative.should be_nil
+        @test_volume.xpath.should be_nil
+        @test_volume.xpath_constrained.should be_nil
 
-      @test_volume.xpath_relative.should == 'detail[@type="volume"]'
-      @test_volume.xpath.should == '//detail[@type="volume"]'
-      @test_volume.xpath_constrained.should == '//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"')
-    end
-    it "should trigger update on any child objects" do
-      mock_child = mock("child term")
-      mock_child.expects(:generate_xpath_queries!).times(3)
-      @test_name_part.expects(:children).returns({1=>mock_child, 2=>mock_child, 3=>mock_child})
-      @test_name_part.generate_xpath_queries!
+        @test_volume.generate_xpath_queries!.should == @test_volume
+
+        @test_volume.xpath_relative.should == 'detail[@type="volume"]'
+        @test_volume.xpath.should == '//detail[@type="volume"]'
+        @test_volume.xpath_constrained.should == '//detail[@type="volume" and contains(number, "#{constraint_value}")]'.gsub('"', '\"')
+      end
+      it "should trigger update on any child objects" do
+        mock_child = mock("child term")
+        mock_child.expects(:generate_xpath_queries!).times(3)
+        @test_name_part.expects(:children).returns({1=>mock_child, 2=>mock_child, 3=>mock_child})
+        @test_name_part.generate_xpath_queries!
+      end
     end
-  end
 
-  describe "#xml_builder_template" do
+    describe "#xml_builder_template" do
 
-    it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
-      @test_date.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
-      @test_person.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\' )'
-      @test_affiliation.xml_builder_template.should == 'xml.affiliation( \'#{builder_new_value}\' )'
-    end
-    it "should accept extra options" do
-      marcrelator_role_xml_builder_template = 'xml.roleTerm( \'#{builder_new_value}\', \'type\'=>\'code\', \'authority\'=>\'marcrelator\' )'
-      @test_role_code.xml_builder_template(:attributes=>{"authority"=>"marcrelator"}).should == marcrelator_role_xml_builder_template
-    end
+      it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block)" do
+        @test_date.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\', \'type\'=>\'date\' )'
+        @test_person.xml_builder_template.should == 'xml.namePart( \'#{builder_new_value}\' )'
+        @test_affiliation.xml_builder_template.should == 'xml.affiliation( \'#{builder_new_value}\' )'
+      end
 
-    it "should work for namespaced nodes" do
-      @ical_date = OM::XML::Term.new(:ical_date, :path=>"ical:date")
-      @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
-      @ical_date = OM::XML::Term.new(:ical_date, :path=>"date", :namespace_prefix=>"ical")
-      @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
-    end
+      it "should accept extra options" do
+        # Expected marcrelator_role_xml_builder_template.
+        # Include both version to handle either ordering of the hash -- a band-aid hack to fix failing test.
+        e1 = %q{xml.roleTerm( '#{builder_new_value}', 'type'=>'code', 'authority'=>'marcrelator' )}
+        e2 = %q{xml.roleTerm( '#{builder_new_value}', 'authority'=>'marcrelator', 'type'=>'code' )}
+        got = @test_role_code.xml_builder_template(:attributes=>{"authority"=>"marcrelator"})
+        [e1, e2].should include(got)
+      end
 
-    it "should work for nodes with default_content_path" do
-      @test_volume.xml_builder_template.should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
-    end
+      it "should work for namespaced nodes" do
+        @ical_date = OM::XML::Term.new(:ical_date, :path=>"ical:date")
+        @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
+        @ical_date = OM::XML::Term.new(:ical_date, :path=>"date", :namespace_prefix=>"ical")
+        @ical_date.xml_builder_template.should == "xml[\'ical\'].date( '\#{builder_new_value}' )"
+      end
 
-    it "should support terms that are attributes" do
-      @type_attribute_term = OM::XML::Term.new(:type_attribute, :path=>{:attribute=>:type})
-      @type_attribute_term.xml_builder_template.should == "xml.@type( '\#{builder_new_value}' )"
-    end
+      it "should work for nodes with default_content_path" do
+        @test_volume.xml_builder_template.should == "xml.detail( \'type\'=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
+      end
 
-    it "should support terms with namespaced attributes" do
-      @french_title = OM::XML::Term.new(:french_title, :path=>"title", :attributes=>{"xml:lang"=>"fre"})
-      @french_title.xml_builder_template.should == "xml.title( '\#{builder_new_value}', 'xml:lang'=>'fre' )"
-    end
+      it "should support terms that are attributes" do
+        @type_attribute_term = OM::XML::Term.new(:type_attribute, :path=>{:attribute=>:type})
+        @type_attribute_term.xml_builder_template.should == "xml.@type( '\#{builder_new_value}' )"
+      end
 
-    it "should support terms that are namespaced attributes" do
-      @xml_lang_attribute_term = OM::XML::Term.new(:xml_lang_attribute, :path=>{:attribute=>"xml:lang"})
-      @xml_lang_attribute_term.xml_builder_template.should == "xml.@xml:lang( '\#{builder_new_value}' )"
-    end
-    
-    it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block) for terms that share a name with an existing method on the builder" do
-     	@test_type.xml_builder_template.should == 'xml.class_( \'#{builder_new_value}\' )'
+      it "should support terms with namespaced attributes" do
+        @french_title = OM::XML::Term.new(:french_title, :path=>"title", :attributes=>{"xml:lang"=>"fre"})
+        @french_title.xml_builder_template.should == "xml.title( '\#{builder_new_value}', 'xml:lang'=>'fre' )"
+      end
+
+      it "should support terms that are namespaced attributes" do
+        @xml_lang_attribute_term = OM::XML::Term.new(:xml_lang_attribute, :path=>{:attribute=>"xml:lang"})
+        @xml_lang_attribute_term.xml_builder_template.should == "xml.@xml:lang( '\#{builder_new_value}' )"
+      end
+      
+      it "should generate a template call for passing into the builder block (assumes 'xml' as the argument for the block) for terms that share a name with an existing method on the builder" do
+        @test_type.xml_builder_template.should == 'xml.class_( \'#{builder_new_value}\' )'
+      end
     end
   end
-
 end