xml-mapping 0.8

data/test/xml_mapping_test.rb

@@ -0,0 +1,182 @@
+require File.dirname(__FILE__)+"/tests_init"
+
+require 'test/unit'
+require 'company'
+
+module XML::Mapping
+  def ==(other)
+    Marshal.dump(self) == Marshal.dump(other)
+  end
+end
+
+class XmlMappingTest < Test::Unit::TestCase
+  def setup
+    # need to undo mapping class definitions that may have been
+    # established by other tests (and outlive those tests)
+
+    # this requires some ugly hackery with internal variables
+    XML::Mapping.module_eval <<-EOS
+      Classes_w_default_rootelt_names.clear
+      Classes_w_nondefault_rootelt_names.clear
+    EOS
+    Object.send(:remove_const, "Company")
+    Object.send(:remove_const, "Address")
+    Object.send(:remove_const, "Office")
+    Object.send(:remove_const, "Customer")
+    $".delete "company.rb"
+    $:.unshift File.dirname(__FILE__)  # test/unit may have undone this (see test/unit/collector/dir.rb)
+    require 'company'
+
+    @xml = REXML::Document.new(File.new(File.dirname(__FILE__) + "/fixtures/company1.xml"))
+    @c = Company.load_from_xml(@xml.root)
+  end
+
+  def test_getter_text_node
+    assert_equal "bar", @c.ent2
+  end
+
+  def test_getter_int_node
+    assert_equal 18, @c.offices[1].address.number
+  end
+
+  def test_getter_boolean_node
+    path=XML::XXPath.new("offices/office[2]/classified")
+    assert_equal(path.first(@xml.root).text == "yes",
+                 @c.offices[1].classified)
+  end
+
+  def test_getter_hash_node
+    assert_equal 4, @c.customers.keys.size
+    ["cm", "ernie", "jim", "sad"].zip(@c.customers.keys.sort).each do |exp,ckey|
+      assert_equal exp, ckey
+      assert_equal exp, @c.customers[ckey].uid
+    end
+  end
+  
+  def test_getter_array_node
+    assert_equal ["pencils", "weapons of mass destruction"],
+          @c.offices.map{|o|o.speciality}
+  end
+  
+  
+  def test_setter_text_node
+    @c.ent2 = "lalala"
+    assert_equal "lalala", REXML::XPath.first(@c.save_to_xml, "arrtest/entry[2]").text
+  end
+  
+  
+  def test_setter_array_node
+    xml=@c.save_to_xml
+    assert_equal ["pencils", "weapons of mass destruction"],
+          XML::XXPath.new("offices/office/@speciality").all(xml).map{|n|n.text}
+  end
+  
+  
+  def test_setter_hash_node
+    xml=@c.save_to_xml
+    assert_equal @c.customers.keys.sort,
+          XML::XXPath.new("customers/customer/@uid").all(@xml.root).map{|n|n.text}.sort
+  end
+  
+  
+  def test_setter_boolean_node
+    @c.offices[0].classified = !@c.offices[0].classified
+    xml=@c.save_to_xml
+    assert_equal @c.offices[0].classified,
+           XML::XXPath.new("offices/office[1]/classified").first(xml).text == "yes"
+  end
+
+
+  def test_root_element
+    assert_equal @c, XML::Mapping.load_object_from_file(File.dirname(__FILE__) + "/fixtures/company1.xml")
+    assert_equal @c, XML::Mapping.load_object_from_xml(@xml.root)
+
+    assert_equal "company", Company.root_element_name
+    assert_equal Company, XML::Mapping.class_for_root_elt_name("company")
+    xml=@c.save_to_xml
+    assert_equal "company", xml.name
+    # Company.root_element_name 'my-test'
+    Company.class_eval <<-EOS
+        root_element_name 'my-test'
+    EOS
+    assert_equal "my-test", Company.root_element_name
+    assert_equal Company, XML::Mapping.class_for_root_elt_name("my-test")
+    assert_nil XML::Mapping.class_for_root_elt_name("company")
+    xml=@c.save_to_xml
+    assert_equal "my-test", xml.name
+    assert_equal "office", @c.offices[0].save_to_xml.name
+
+    assert_raises(XML::MappingError) {
+      XML::Mapping.load_object_from_xml @xml.root
+    }
+    @xml.root.name = 'my-test'
+    assert_equal @c, XML::Mapping.load_object_from_xml(@xml.root)
+
+    # white-box tests
+    assert_equal [["my-test", Company]], XML::Mapping::Classes_w_nondefault_rootelt_names.sort
+    assert_equal [["address", Address], ["customer", Customer], ["office", Office]],
+          XML::Mapping::Classes_w_default_rootelt_names.sort
+  end
+
+
+  def test_optional_flag
+    hamburg_address_path = XML::XXPath.new("offices/office[1]/address")
+    baghdad_address_path = XML::XXPath.new("offices/office[2]/address")
+    hamburg_zip_path = XML::XXPath.new("offices/office[1]/address/zip")
+    baghdad_zip_path = XML::XXPath.new("offices/office[2]/address/zip")
+
+    assert_equal 18282, @c.offices[0].address.zip
+    assert_equal 12576, @c.offices[1].address.zip
+    xml=@c.save_to_xml
+    assert_equal "18282", hamburg_zip_path.first(xml).text
+    assert_nil baghdad_zip_path.first(xml,:allow_nil=>true)
+    @c.offices[1].address.zip = 12577
+    xml=@c.save_to_xml
+    assert_equal "12577", baghdad_zip_path.first(xml).text
+    c2 = Company.load_from_xml(xml)
+    assert_equal 12577, c2.offices[1].address.zip
+    @c.offices[1].address.zip = 12576
+    xml=@c.save_to_xml
+    assert_nil baghdad_zip_path.first(xml,:allow_nil=>true)
+
+    hamburg_address_path.first(xml).delete_element("zip")
+    c3 = Company.load_from_xml(xml)
+    assert_equal 12576, c3.offices[0].address.zip
+    hamburg_address_path.first(xml).delete_element("city")
+    assert_raises(XML::MappingError) {
+      Company.load_from_xml(xml)
+    }
+  end
+
+
+  def test_optional_flag_nodefault
+    hamburg_address_path = XML::XXPath.new("offices/office[1]/address")
+    hamburg_street_path = XML::XXPath.new("offices/office[1]/address/street")
+
+    assert_equal hamburg_street_path.first(@xml.root).text,
+          @c.offices[0].address.street
+
+    hamburg_address_path.first(@xml.root).delete_element("street")
+    c2 = Company.load_from_xml(@xml.root)
+    assert_nil c2.offices[0].address.street
+
+    xml2=c2.save_to_xml
+    assert_nil hamburg_street_path.first(xml2,:allow_nil=>true)
+  end
+
+
+  def test_polymorphic_node
+    assert_equal 3, @c.stuff.size
+    assert_equal 'Saddam Hussein', @c.stuff[0].name
+    assert_equal 'Berlin', @c.stuff[1].city
+    assert_equal 'weapons of mass destruction', @c.stuff[2].speciality
+
+    @c.stuff[1].city = 'Munich'
+    @c.stuff[2].classified = false
+
+    xml2=@c.save_to_xml
+    assert_equal 'Munich', xml2.root.elements[5].elements[2].elements[1].text
+    assert_equal 'no',     xml2.root.elements[5].elements[3].elements[1].text
+  end
+
+end

data/test/xpath_test.rb

@@ -0,0 +1,273 @@
+require File.dirname(__FILE__)+"/tests_init"
+
+require 'test/unit'
+
+require "rexml/document"
+require "xml/xxpath"
+
+
+class XPathTest < Test::Unit::TestCase
+  include REXML
+
+  def setup
+    @d = Document.new <<-EOS
+    <bla>
+      <foo>x</foo>
+      <bar>bar1</bar>
+      <foo key='xy'>
+        y
+        <u/>
+      </foo>
+    </bla>
+    EOS
+  end
+
+  def test_read_byname
+    assert_equal @d.root.elements.to_a("foo"), XML::XXPath.new("foo").all(@d.root)
+    assert_equal @d.root.elements.to_a("foo")[1].elements.to_a("u"), XML::XXPath.new("foo/u").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo/notthere").all(@d.root)
+  end
+
+
+  def test_read_byidx
+    assert_equal [@d.root.elements[1]], XML::XXPath.new("foo[1]").all(@d.root)
+    assert_equal [@d.root.elements[3]], XML::XXPath.new("foo[2]").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo[10]").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo[3]").all(@d.root)
+  end
+
+
+  def test_read_byall
+    assert_equal @d.root.elements.to_a, XML::XXPath.new("*").all(@d.root)
+    assert_equal [], XML::XXPath.new("notthere/*").all(@d.root)
+  end
+
+
+  def test_read_byattr
+    assert_equal [@d.root.elements[3]], XML::XXPath.new("foo[@key='xy']").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo[@key='notthere']").all(@d.root)
+    assert_equal [], XML::XXPath.new("notthere[@key='xy']").all(@d.root)
+  end
+
+
+  def test_attribute
+    elt = @d.root.elements[3]
+    attr1 = XML::XXPath::Accessors::Attribute.new(elt,"key",false)
+    attr2 = XML::XXPath::Accessors::Attribute.new(elt,"key",false)
+    assert_not_nil attr1
+    assert_not_nil attr2
+    assert_equal attr1,attr2  # tests Attribute.==
+    assert_nil XML::XXPath::Accessors::Attribute.new(elt,"notthere",false)
+    assert_nil XML::XXPath::Accessors::Attribute.new(elt,"notthere",false)
+    newattr = XML::XXPath::Accessors::Attribute.new(elt,"new",true)
+    assert_not_nil newattr
+    assert_equal newattr, XML::XXPath::Accessors::Attribute.new(elt,"new",false)
+    newattr.text = "lala"
+    assert_equal "lala", elt.attributes["new"]
+  end
+
+  def test_read_byattrname
+    assert_equal [XML::XXPath::Accessors::Attribute.new(@d.root.elements[3],"key",false)],
+                 XML::XXPath.new("foo/@key").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo/@notthere").all(@d.root)
+  end
+
+
+  def test_read_byidx_then_name
+    assert_equal [@d.root.elements[3].elements[1]], XML::XXPath.new("foo[2]/u").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo[2]/notthere").all(@d.root)
+    assert_equal [], XML::XXPath.new("notthere[2]/u").all(@d.root)
+    assert_equal [], XML::XXPath.new("foo[3]/u").all(@d.root)
+  end
+
+  def test_read_first
+    assert_equal @d.root.elements[3].elements[1], XML::XXPath.new("foo[2]/u").first(@d.root)
+  end
+
+  def test_read_first_nil
+    assert_equal nil, XML::XXPath.new("foo[2]/notthere").first(@d.root, :allow_nil=>true)
+  end
+
+  def test_read_first_exception
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("foo[2]/notthere").first(@d.root)
+    }
+  end
+
+
+  def test_write_noop
+    assert_equal @d.root.elements[1], XML::XXPath.new("foo").first(@d.root, :ensure_created=>true)
+    assert_equal @d.root.elements[3].elements[1], XML::XXPath.new("foo[2]/u").first(@d.root, :ensure_created=>true)
+    # TODO: deep-compare of REXML documents?
+  end
+
+  def test_write_byname_then_name
+    s1 = @d.elements[1].elements.size
+    s2 = @d.elements[1].elements[1].elements.size
+    node = XML::XXPath.new("foo/new1").first(@d.root, :ensure_created=>true)
+    assert_equal "new1", node.name
+    assert node.attributes.empty?
+    assert_equal @d.elements[1].elements[1].elements[1], node
+    assert_equal s1, @d.elements[1].elements.size
+    assert_equal s2+1, @d.elements[1].elements[1].elements.size
+  end
+
+
+  def test_write_byidx
+    XML::XXPath.new("foo[2]").first(@d.root, :ensure_created=>true)
+    # TODO: deep-compare of REXML documents?
+    assert_equal 2, @d.root.elements.select{|elt| elt.name=="foo"}.size
+    node = XML::XXPath.new("foo[10]").first(@d.root, :ensure_created=>true)
+    assert_equal 10, @d.root.elements.select{|elt| elt.name=="foo"}.size
+    assert_equal "foo", node.name
+  end
+
+
+  def test_write_byattrname
+    elt = @d.root.elements[3]
+    s1 = elt.attributes.size
+    attr_key = XML::XXPath.new("foo[2]/@key").first(@d.root, :ensure_created=>true)
+    assert_equal elt.attributes["key"], attr_key.text
+
+    attr_new = XML::XXPath.new("foo[2]/@new").first(@d.root, :ensure_created=>true)
+    attr_new.text = "haha"
+    assert_equal "haha", attr_new.text
+    assert_equal "haha", elt.attributes["new"]
+    assert_equal s1+1, elt.attributes.size
+  end
+
+
+  def test_write_byname_and_attr
+    node1 = XML::XXPath.new("hiho[@blubb='bla']").first(@d.root,:ensure_created=>true)
+    node2 = XML::XXPath.new("hiho[@blubb='bla']").first(@d.root,:ensure_created=>true)
+    node3 = XML::XXPath.new("hiho[@blubb2='bla2']").first(@d.root,:ensure_created=>true)
+    assert_equal node1, node2
+    assert_equal node2, node3
+    assert_equal "hiho", node1.name
+    assert_equal 4, @d.root.elements.size
+    assert_equal @d.root.elements[4], node1
+    assert_equal @d.root.elements[4], node3
+    assert_equal 'bla', node3.attributes['blubb']
+    assert_equal 'bla2', node3.attributes['blubb2']
+
+    node4 = XML::XXPath.new("hiho[@blubb='foo42']").first(@d.root,:ensure_created=>true)
+    assert_not_equal node3, node4
+    assert_equal 5, @d.root.elements.size
+    assert_equal @d.root.elements[5], node4
+    assert_equal 'foo42', node4.attributes['blubb']
+  end
+
+
+  def test_create_new_byname
+    s1 = @d.elements[1].elements.size
+    s2 = @d.elements[1].elements[1].elements.size
+    startnode = @d.elements[1].elements[1]
+    node1 = XML::XXPath.new("new1").create_new(startnode)
+    node2 = XML::XXPath.new("new1").first(startnode, :create_new=>true) #same as .create_new(...)
+    assert_equal "new1", node1.name
+    assert_equal "new1", node2.name
+    assert node1.attributes.empty?
+    assert node2.attributes.empty?
+    assert_equal @d.elements[1].elements[1].elements[1], node1
+    assert_equal @d.elements[1].elements[1].elements[2], node2
+    assert_equal s1, @d.elements[1].elements.size
+    assert_equal s2+2, @d.elements[1].elements[1].elements.size
+  end
+
+
+  def test_create_new_byname_then_name
+    s1 = @d.elements[1].elements.size
+    node1 = XML::XXPath.new("foo/new1").create_new(@d.root)
+    node2 = XML::XXPath.new("foo/new1").create_new(@d.root)
+    assert_equal "new1", node1.name
+    assert_equal "new1", node2.name
+    assert node1.attributes.empty?
+    assert node2.attributes.empty?
+    assert_equal @d.elements[1].elements[s1+1].elements[1], node1
+    assert_equal @d.elements[1].elements[s1+2].elements[1], node2
+    assert_equal s1+2, @d.elements[1].elements.size
+  end
+
+
+  def test_create_new_byidx
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("foo[2]").create_new(@d.root)
+    }
+    node1 = XML::XXPath.new("foo[3]").create_new(@d.root)
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("foo[3]").create_new(@d.root)
+    }
+    assert_equal @d.elements[1].elements[4], node1
+    assert_equal "foo", node1.name
+    node2 = XML::XXPath.new("foo[4]").create_new(@d.root)
+    assert_equal @d.elements[1].elements[5], node2
+    assert_equal "foo", node2.name
+    node3 = XML::XXPath.new("foo[10]").create_new(@d.root)
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("foo[10]").create_new(@d.root)
+    }
+    XML::XXPath.new("foo[11]").create_new(@d.root)
+    assert_equal @d.elements[1].elements[11], node3
+    assert_equal "foo", node3.name
+    # @d.write
+  end
+
+  def test_create_new_byname_then_idx
+    node1 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
+    node2 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
+      # same as create_new
+    node3 = XML::XXPath.new("hello/bar[3]").create_new(@d.root)
+    assert_equal @d.elements[1].elements[4].elements[3], node1
+    assert_equal @d.elements[1].elements[5].elements[3], node2
+    assert_equal @d.elements[1].elements[6].elements[3], node3
+    assert_not_equal node1, node2
+    assert_not_equal node1, node3
+    assert_not_equal node2, node3
+  end
+
+
+  def test_create_new_byattrname
+    node1 = XML::XXPath.new("@lala").create_new(@d.root)
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("@lala").create_new(@d.root)
+    }
+    assert node1.kind_of?(XML::XXPath::Accessors::Attribute)
+    node1.text = "val1"
+    assert_equal "val1", @d.elements[1].attributes["lala"]
+    foo2 = XML::XXPath.new("foo[2]").first(@d.root)
+    assert_raises(XML::XXPathError) {
+      XML::XXPath.new("@key").create_new(foo2)
+    }
+    node2 = XML::XXPath.new("@bar").create_new(foo2)
+    assert node2.kind_of?(XML::XXPath::Accessors::Attribute)
+    node2.text = "val2"
+    assert_equal "val2", @d.elements[1].elements[3].attributes["bar"]
+  end
+
+
+  def test_create_new_byname_and_attr
+    node1 = XML::XXPath.new("hiho[@blubb='bla']").create_new(@d.root)
+    node2 = XML::XXPath.new("hiho[@blubb='bla']").create_new(@d.root)
+    node3 = XML::XXPath.new("hiho[@blubb2='bla']").create_new(@d.root)
+    assert_equal "hiho", node1.name
+    assert_equal "hiho", node2.name
+    assert_equal @d.root.elements[4], node1
+    assert_equal @d.root.elements[5], node2
+    assert_equal @d.root.elements[6], node3
+    assert_not_equal @d.root.elements[5], node1
+  end
+
+
+  def test_unspecifiedness
+    node1 = XML::XXPath.new("foo/hello").create_new(@d.root)
+    assert(!(node1.unspecified?))
+    assert_equal @d.root, node1.parent.parent
+    node2 = XML::XXPath.new("foo/*").create_new(@d.root)
+    assert_equal @d.root, node2.parent.parent
+    assert node2.unspecified?
+    node2.name = "newone"
+    assert_equal "newone", node2.name
+    assert(!(node2.unspecified?))
+  end
+
+end