om 0.1.10 → 1.0.0

data/spec/unit/document_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::Document" do
+  
+  before(:all) do
+    #ModsHelpers.name_("Beethoven, Ludwig van", :date=>"1770-1827", :role=>"creator")
+    class DocumentTest 
+
+      include OM::XML::Document    
+      
+      # Could add support for multiple root declarations.  
+      #  For now, assume that any modsCollections have already been broken up and fed in as individual mods documents
+      # root :mods_collection, :path=>"modsCollection", 
+      #           :attributes=>[],
+      #           :subelements => :mods
+      
+      set_terminology do |t|
+        t.root(:path=>"mods", :xmlns=>"http://www.loc.gov/mods/v3", :schema=>"http://www.loc.gov/standards/mods/v3/mods-3-2.xsd")
+
+        t.title_info(:path=>"titleInfo") {
+          t.main_title(:path=>"title", :label=>"title")
+          t.language(:path=>{:attribute=>"lang"})
+        }                 
+        # This is a mods:name.  The underscore is purely to avoid namespace conflicts.
+        t.name_ {
+          # this is a namepart
+          t.namePart(:index_as=>[:searchable, :displayable, :facetable, :sortable], :required=>:true, :type=>:string, :label=>"generic name")
+          # affiliations are great
+          t.affiliation
+          t.displayForm
+          t.role(:ref=>[:role])
+          t.description
+          t.date(:path=>"namePart", :attributes=>{:type=>"date"})
+          t.last_name(:path=>"namePart", :attributes=>{:type=>"family"})
+          t.first_name(:path=>"namePart", :attributes=>{:type=>"given"}, :label=>"first name")
+          t.terms_of_address(:path=>"namePart", :attributes=>{:type=>"termsOfAddress"})
+        }
+        # lookup :person, :first_name        
+        t.person(:ref=>:name, :attributes=>{:type=>"personal"})
+
+        t.role {
+          t.text(:path=>"roleTerm",:attributes=>{:type=>"text"})
+          t.code(:path=>"roleTerm",:attributes=>{:type=>"code"})
+        }
+        t.journal(:path=>'relatedItem', :attributes=>{:type=>"host"}) {
+          t.title_info
+          t.origin_info(:path=>"originInfo")
+          t.issn(:path=>"identifier", :attributes=>{:type=>"issn"})
+          t.issue(:ref=>:issue)
+        }
+        t.issue(:path=>"part") {
+          t.volume(:path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+          t.level(:path=>"detail", :attributes=>{:type=>"number"}, :default_content_path=>"number")
+          t.start_page(:path=>"pages", :attributes=>{:type=>"start"})
+          t.end_page(:path=>"pages", :attributes=>{:type=>"end"})
+          # t.start_page(:path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "start")
+          # t.end_page(:path=>"extent", :attributes=>{:unit=>"pages"}, :default_content_path => "end")
+          t.publication_date(:path=>"date")
+        }
+      end
+           
+    end
+        
+  end
+  
+  before(:each) do
+    @fixturemods = DocumentTest.from_xml( fixture( File.join("CBF_MODS", "ARS0025_016.xml") ) )
+    article_xml = fixture( File.join("mods_articles", "hydrangea_article1.xml") )
+    @mods_article = DocumentTest.from_xml(article_xml)
+  end
+  
+  after(:all) do
+    Object.send(:remove_const, :DocumentTest)
+  end
+    
+  describe ".ox_namespaces" do
+    it "should merge terminology namespaces with document namespaces" do
+      @fixturemods.ox_namespaces.should == {"oxns"=>"http://www.loc.gov/mods/v3", "xmlns:ns2"=>"http://www.w3.org/1999/xlink", "xmlns:xsi"=>"http://www.w3.org/2001/XMLSchema-instance", "xmlns:ns3"=>"http://www.loc.gov/mods/v3", "xmlns"=>"http://www.loc.gov/mods/v3"}
+    end
+  end
+  
+  
+  describe ".find_by_terms_and_value" do
+    it "should fail gracefully if you try to look up nodes for an undefined property" do
+      pending "better to get an informative error?"
+      @fixturemods.find_by_terms_and_value(:nobody_home).should == []
+    end
+    it "should use Nokogiri to retrieve a NodeSet corresponding to the term pointers" do
+      @mods_article.find_by_terms_and_value( :person ).length.should == 2
+    end
+
+    it "should allow you to search by term pointer" do
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal"]', @fixturemods.ox_namespaces)
+      @fixturemods.find_by_terms_and_value(:person)
+    end
+    it "should allow you to constrain your searches" do
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal" and contains(., "Beethoven, Ludwig van")]', @fixturemods.ox_namespaces)
+      @fixturemods.find_by_terms_and_value(:person, "Beethoven, Ludwig van")
+    end
+    it "should allow you to use complex constraints" do
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal"]/oxns:namePart[@type="date" and contains(., "2010")]', @fixturemods.ox_namespaces)
+      @fixturemods.find_by_terms_and_value(:person, :date=>"2010")
+      
+      @fixturemods.ng_xml.expects(:xpath).with('//oxns:name[@type="personal"]/oxns:role[contains(., "donor")]', @fixturemods.ox_namespaces)
+      @fixturemods.find_by_terms_and_value(:person, :role=>"donor")
+    end
+  end
+  describe ".find_by_terms" do
+    it "should use Nokogiri to retrieve a NodeSet corresponding to the combination of term pointers and array/nodeset indexes" do
+      @mods_article.find_by_terms( :person ).length.should == 2
+      @mods_article.find_by_terms( {:person=>1} ).first.should == @mods_article.ng_xml.xpath('//oxns:name[@type="personal"][2]', "oxns"=>"http://www.loc.gov/mods/v3").first
+      @mods_article.find_by_terms( {:person=>1}, :first_name ).class.should == Nokogiri::XML::NodeSet
+      @mods_article.find_by_terms( {:person=>1}, :first_name ).first.text.should == "Siddartha"
+    end
+    it "should support accessors whose relative_xpath is a lookup array instead of an xpath string" do
+      # pending "this only impacts scenarios where we want to display & edit"
+      DocumentTest.terminology.retrieve_term(:title_info, :language).path.should == {:attribute=>"lang"}
+      # @sample.retrieve( :title, 1 ).first.text.should == "Artikkelin otsikko Hydrangea artiklan 1"
+      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
+    end
+    
+    it "should support xpath queries as the pointer" do
+      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
+    end
+    
+    it "should return nil if the xpath fails to generate" do
+      pending "Can't decide if it's better to return nil or raise an error.  Choosing informative errors for now."
+      @mods_article.find_by_terms( {:foo=>20}, :bar ).should == nil
+    end
+
+    it "should support terms that point to attributes instead of nodes" do
+      @mods_article.find_by_terms( {:title_info=>1}, :language ).first.text.should == "finnish"
+    end
+
+    it "should support xpath queries as the pointer" do
+      @mods_article.find_by_terms('//oxns:name[@type="personal"][1]/oxns:namePart[1]').first.text.should == "FAMILY NAME"
+    end
+  end
+   
+end

data/spec/unit/generator_spec.rb

@@ -51,7 +51,13 @@ describe "OM::XML::Generator" do
   describe '#generate' do
     it "should use the corresponding builder template(s) to generate the node" do
       GeneratorTest.generate(:mods, "foo").root.to_xml.should == "<mods>foo</mods>"
-      GeneratorTest.generate([:person,:role], "creator", {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}}).root.to_xml.should == "<role type=\"code\" authority=\"marcrelator\">\n  <roleTerm>creator</roleTerm>\n</role>"
+      # GeneratorTest.generate([:person,:role], "creator", {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}}).root.to_xml.should == "<role authority=\"marcrelator\" type=\"code\">\n  <roleTerm>creator</roleTerm>\n</role>"
+      generated_node = GeneratorTest.generate([:person,:role], "creator", {:attributes=>{"type"=>"code", "authority"=>"marcrelator"}})
+      # generated_node.should have_node 'role[@authority="marcrelator"][@type="code"]' do
+      #   with_node "roleTerm", "creator"
+      # end
+      generated_node.xpath('./role[@authority="marcrelator"][@type="code"]').xpath("./roleTerm").text.should == "creator"
+
     end
     it "should return Nokogiri Documents" do
       GeneratorTest.generate(:mods, "foo").class.should == Nokogiri::XML::Document

data/spec/unit/named_term_proxy_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::NamedTermProxy" do
+  
+  before(:all) do
+    
+    @test_terminology_builder = OM::XML::Terminology::Builder.new do |t|
+      t.parent {
+        t.foo {
+          t.bar
+        }
+        t.my_proxy(:proxy=>[:foo, :bar])
+      }
+      t.adoptive_parent(:ref=>[:parent], :attributes=>{:type=>"adoptive"})
+    end
+    
+    @test_terminology = @test_terminology_builder.build
+    @test_proxy = @test_terminology.retrieve_term(:parent, :my_proxy)
+    @proxied_term = @test_terminology.retrieve_term(:parent, :foo, :bar)
+    @adoptive_parent = @test_terminology.retrieve_term(:adoptive_parent)
+  end
+    
+  it "should proxy all extra methods to the proxied object" do
+    [:xpath, :xpath_relative, :xml_builder_template].each do |method|
+      @proxied_term.expects(method)
+      @test_proxy.send(method)
+    end
+  end
+  it "should proxy the term specified by the builder" do
+    @test_proxy.proxied_term.should == @test_terminology.retrieve_term(:parent, :foo, :bar)
+    @test_proxy.xpath.should == "//oxns:parent/oxns:foo/oxns:bar"
+  end
+  it "should search relative to the parent term when finding the term to proxy" do
+    proxy2 = @test_terminology.retrieve_term(:adoptive_parent, :my_proxy)    
+    proxy2.proxied_term.should == @test_terminology.retrieve_term(:adoptive_parent, :foo, :bar)
+    proxy2.xpath.should == '//oxns:parent[@type="adoptive"]/oxns:foo/oxns:bar'
+  end
+end

data/spec/unit/node_generator_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::NodeGenerator" do
+  
+  
+  before(:each) do
+    @test_mods_term = OM::XML::Term.new(:mods)
+    @test_volume_term = OM::XML::Term.new(:volume, :path=>"detail", :attributes=>{:type=>"volume"}, :default_content_path=>"number")
+  end
+  
+  describe '#generate' do
+    it "should use the corresponding builder template(s) to generate the node" do
+      OM::XML::NodeGenerator.generate(@test_mods_term, "foo").root.to_xml.should == "<mods>foo</mods>"
+      generated_node = OM::XML::NodeGenerator.generate(@test_volume_term, "108", {:attributes=>{"extraAttr"=>"my value"}})
+      generated_node.xpath('./detail[@type="volume"][@extraAttr="my value"]').xpath("./number").text.should == "108"
+      # Would be great if we wrote a have_node custom rspec matcher...
+      # generated_node.should have_node 'role[@authority="marcrelator"][@type="code"]' do
+      #   with_node "roleTerm", "creator"
+      # end
+    end
+    it "should return Nokogiri Documents" do
+      OM::XML::NodeGenerator.generate(@test_mods_term, "foo").class.should == Nokogiri::XML::Document
+    end
+  end
+  
+end

data/spec/unit/properties_spec.rb

@@ -312,4 +312,4 @@ describe "OM::XML::Properties" do
     end
   end
    
-end
+end

data/spec/unit/term_builder_spec.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+describe "OM::XML::Term::Builder" do
+  
+  before(:each) do
+    @test_terminology_builder = OM::XML::Terminology::Builder.new do |t|
+      t.fruit_trees {
+        t.citrus(:attributes=>{"citric_acid"=>"true"}, :index_as=>[:facetable]) {
+          t.randomness
+        }
+        t.stone_fruit(:path=>"prunus", :attributes=>{:genus=>"Prunus"}) 
+        t.peach(:ref=>[:fruit_trees, :stone_fruit], :attributes=>{:subgenus=>"Amygdalus", :species=>"Prunus persica"})
+        t.nectarine(:ref=>[:fruit_trees, :peach], :attributes=>{:cultivar=>"nectarine"})
+        t.almond(:ref=>[:fruit_trees, :peach], :attributes=>{:species=>"Prunus dulcis"})
+      }
+      t.coconut(:ref=>:pineapple)
+      t.banana(:ref=>:coconut)
+      t.pineapple(:ref=>:banana)
+    end
+    
+    @citrus = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :citrus)
+    @stone_fruit = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :stone_fruit)
+    @peach = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :peach)
+    @nectarine = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :nectarine)
+    @almond = @test_terminology_builder.retrieve_term_builder(:fruit_trees, :almond)
+    @pineapple = @test_terminology_builder.retrieve_term_builder(:pineapple)
+  end
+  
+  before(:each) do
+    @test_builder = OM::XML::Term::Builder.new("term1")
+    @test_builder_2 = OM::XML::Term::Builder.new("term2")
+  end
+  
+  describe '#new' do
+   it "should set terminology_builder attribute if provided" do
+     mock_terminology_builder = mock("TerminologyBuilder")
+     OM::XML::Term::Builder.new("term1", mock_terminology_builder).terminology_builder.should == mock_terminology_builder
+   end
+  end
+  
+  describe "configuration methods" do
+    it "should set the corresponding .settings value return the mapping object" do
+      [:path, :index_as, :required, :data_type, :variant_of, :path, :attributes, :default_content_path].each do |method_name|
+        @test_builder.send(method_name, "#{method_name.to_s}foo").should == @test_builder
+        @test_builder.settings[method_name].should == "#{method_name.to_s}foo"
+      end
+    end
+    it "should be chainable" do
+      test_builder = OM::XML::Term::Builder.new("chainableTerm").index_as(:facetable, :searchable, :sortable, :displayable).required(true).data_type(:text)  
+      resulting_settings = test_builder.settings
+      resulting_settings[:index_as].should == [:facetable, :searchable, :sortable, :displayable]
+      resulting_settings[:required].should == true 
+      resulting_settings[:data_type].should == :text
+    end
+  end
+
+  describe "settings" do
+    describe "defaults" do
+      it "should be set" do
+        @test_builder.settings[:required].should == false
+        @test_builder.settings[:data_type].should == :string
+        @test_builder.settings[:variant_of].should be_nil
+        @test_builder.settings[:attributes].should be_nil
+        @test_builder.settings[:default_content_path].should be_nil
+      end
+    end
+  end
+  
+  describe ".add_child" do
+    it "should insert the given Term Builder into the current Term Builder's children" do
+      @test_builder.add_child(@test_builder_2)
+      @test_builder.children[@test_builder_2.name].should == @test_builder_2
+      @test_builder.ancestors.should include(@test_builder_2)
+    end
+  end
+  describe ".retrieve_child" do
+    it "should fetch the child identified by the given name" do
+      @test_builder.add_child(@test_builder_2)
+      @test_builder.retrieve_child(@test_builder_2.name).should == @test_builder.children[@test_builder_2.name]
+    end
+  end
+  describe ".children" do
+    it "should return a hash of Term Builders that are the children of the current object, indexed by name" do
+      @test_builder.add_child(@test_builder_2)
+      @test_builder.children[@test_builder_2.name].should == @test_builder_2
+    end
+  end
+  
+  describe ".build" do
+    it "should build a Term with the given settings and generate its xpath values" do
+      test_builder = OM::XML::Term::Builder.new("requiredTextFacet").index_as([:facetable, :searchable, :sortable, :displayable]).required(true).data_type(:text)  
+      result = test_builder.build
+      result.should be_instance_of OM::XML::Term
+      result.index_as.should == [:facetable, :searchable, :sortable, :displayable]
+      result.required.should == true 
+      result.data_type.should == :text
+      
+      result.xpath.should == OM::XML::TermXpathGenerator.generate_absolute_xpath(result)
+      result.xpath_constrained.should == OM::XML::TermXpathGenerator.generate_constrained_xpath(result)
+      result.xpath_relative.should == OM::XML::TermXpathGenerator.generate_relative_xpath(result)
+    end
+    it "should create proxy terms if :proxy is set" do
+      test_builder = OM::XML::Term::Builder.new("my_proxy").proxy([:foo, :bar])
+      result = test_builder.build
+      result.should be_kind_of OM::XML::NamedTermProxy
+    end
+    it "should set path to match name if it is empty" do
+      @test_builder.settings[:path].should be_nil
+      @test_builder.build.path.should == @test_builder.name.to_s
+    end
+    it "should work recursively, calling .build on any of its children" do
+      OM::XML::Term.any_instance.stubs(:generate_xpath_queries!)
+      built_child1 = OM::XML::Term.new("child1")
+      built_child2 = OM::XML::Term.new("child2")
+
+      mock1 = mock("Builder1", :build => built_child1 )
+      mock2 = mock("Builder2", :build => built_child2 )
+      mock1.stubs(:name).returns("child1")
+      mock2.stubs(:name).returns("child2")
+
+      @test_builder.children = {:mock1=>mock1, :mock2=>mock2}
+      result = @test_builder.build
+      result.children[:child1].should == built_child1
+      result.children[:child2].should == built_child2
+      result.children.length.should == 2
+    end
+  end
+  
+  describe ".lookup_refs" do
+    it "should return an empty array if no refs are declared" do
+      @test_builder.lookup_refs.should == []
+    end
+    it "should should look up the referenced TermBuilder from the terminology_builder" do
+       @peach.lookup_refs.should == [@stone_fruit]
+    end
+    it "should support recursive refs" do
+	    @almond.lookup_refs.should == [@peach, @stone_fruit]
+	  end
+  	it "should raise an error if the TermBuilder does not have a reference to a terminology builder" do
+  	  lambda { OM::XML::Term::Builder.new("referrer").ref("bongos").lookup_refs }.should raise_error(StandardError,"Cannot perform lookup_ref for the referrer builder.  It doesn't have a reference to any terminology builder")
+	  end
+    it "should raise an error if the referece points to a nonexistent term builder" do
+      tb = OM::XML::Term::Builder.new("mork",@test_terminology_builder).ref(:characters, :aliens)
+      lambda { tb.lookup_refs }.should raise_error(OM::XML::Terminology::BadPointerError,"#{tb.name} refers to a Term Builder that doesn't exist.  The bad pointer is [:characters, :aliens]")
+    end
+    it "should raise an error with informative error when given circular references" do
+      lambda { @pineapple.lookup_refs }.should raise_error(OM::XML::Terminology::CircularReferenceError,"Circular reference in Terminology: :pineapple => :banana => :coconut => :pineapple")
+    end
+  end
+  
+  describe ".resolve_refs!" do 
+    it "should do nothing if settings don't include a :ref" do
+      settings_pre = @test_builder.settings
+      children_pre = @test_builder.children
+
+      @test_builder.resolve_refs!
+      @test_builder.settings.should == settings_pre
+      @test_builder.children.should == children_pre
+    end
+    it "should should look up the referenced TermBuilder, use its settings and duplicate its children without changing the name" do
+      term_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
+      term_builder.resolve_refs!
+      # Make sure children and settings were copied
+      term_builder.settings.should == @citrus.settings.merge(:path=>"citrus")
+  	  term_builder.children.should == @citrus.children
+  	  
+  	  # Make sure name and parent of both the term_builder and its target were left alone
+  	  term_builder.name.should == :orange
+  	  @citrus.name.should == :citrus
+    end
+    it "should set path based on the ref's path if set" do
+      [@peach,@almond].each { |x| x.resolve_refs! }
+      @peach.settings[:path].should == "prunus"
+      @almond.settings[:path].should == "prunus"
+    end
+    it "should set path based on the first ref's name if no path is set" do
+      orange_builder = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus)
+      orange_builder.resolve_refs!
+      orange_builder.settings[:path].should == "citrus"
+    end
+    # It should not be a problem if multiple TermBuilders refer to the same child TermBuilder since the parent-child relationship is set up after calling TermBuilder.build 
+    it "should result in clean trees of Terms after building" 
+    
+  	it "should preserve any extra settings specific to this builder (for variant terms)" do
+  	  tb = OM::XML::Term::Builder.new("orange",@test_terminology_builder).ref(:fruit_trees, :citrus).attributes(:color=>"orange").required(true)
+  	  tb.resolve_refs!
+  	  tb.settings.should == {:path=>"citrus", :attributes=>{"citric_acid"=>"true", :color=>"orange"}, :required=>true, :data_type=>:string, :index_as=>[:facetable]}
+	  end
+	  it "should aggregate all settings from refs, combining them with a cascading approach" do
+	    @almond.resolve_refs!
+	    @almond.settings[:attributes].should == {:genus=>"Prunus",:subgenus=>"Amygdalus", :species=>"Prunus dulcis"}
+    end
+  end
+end

data/spec/unit/term_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require "om"
+
+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_affiliation = OM::XML::Term.new(:affiliation)
+    @test_role_code = OM::XML::Term.new(:roleTerm, :attributes=>{:type=>"code"})
+  end
+  
+  describe '#new' do
+    it "should set default values" do
+      @test_name_part.namespace_prefix.should == "oxns"
+    end
+    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
+  
+  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
+  
+  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
+  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"
+    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
+  
+  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
+  
+  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"        
+      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]
+    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"
+    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
+    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]
+    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
+    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)
+    end
+  end
+  
+  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.generate_xpath_queries!.should == @test_volume
+      
+      @test_volume.xpath_relative.should == 'oxns:detail[@type="volume"]'
+      @test_volume.xpath.should == '//oxns:detail[@type="volume"]'
+      @test_volume.xpath_constrained.should == '//oxns:detail[@type="volume" and contains(oxns: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
+  
+  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_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 work for nodes with default_content_path" do      
+      @test_volume.xml_builder_template.should == "xml.detail( :type=>'volume' ) { xml.number( '\#{builder_new_value}' ) }"
+    end
+    
+  end
+  
+end