libxml-ruby 0.9.5-x86-mswin32-60 → 0.9.6-x86-mswin32-60

data/test/tc_document_write.rb

@@ -1,146 +1,118 @@
-require "xml"
+require 'xml'
+require 'tmpdir'
 require 'test/unit'
 
 class TestDocumentWrite < Test::Unit::TestCase
   def setup
-    @doc = XML::Document.new('1.0')
+    # Strip spaces to make testing easier
+    XML.default_keep_blanks = false
+    file = File.join(File.dirname(__FILE__), 'model/bands.xml')
+    @doc = XML::Document.file(file)
   end
 
   def teardown
+    XML.default_keep_blanks = true
     @doc = nil
   end
 
-  def test_klass
-    assert_instance_of(XML::Document, @doc)
+  # ---  to_s tests  ---
+  def test_to_s_default
+    # Default to_s has indentation
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 @doc.to_s)
   end
 
-  def test_version
-    assert_equal('1.0', @doc.version)
-
-    doc = XML::Document.new('6.9')
-    assert_equal('6.9', doc.version)
-  end
-  
-  def test_write_root
-    @doc.root = XML::Node.new('rubynet')
-    assert_instance_of(XML::Node, @doc.root)
-    assert_instance_of(XML::Document, @doc.root.doc)
-    assert_equal("<?xml version=\"1.0\"?>\n<rubynet/>\n", @doc.to_s)
+  def test_to_s_no_global_indentation
+    # No indentation due to global setting
+    XML.indent_tree_output = false
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n<m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n<iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 @doc.to_s)
+  ensure
+    XML.indent_tree_output = true
   end
 
-  def test_write_root
-    @doc.root = XML::Node.new('rubynet')
-    assert_instance_of(XML::Node, @doc.root)
-    assert_instance_of(XML::Document, @doc.root.doc)
-    assert_equal("<?xml version=\"1.0\"?>\n<rubynet/>\n", @doc.to_s(false))
+  def test_to_s_no_indentation
+    # No indentation due to local setting
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                 @doc.to_s(:indent => false))
   end
 
-  def test_child()
-    xml = "<?xml version=\"1.0\"?>\n<rubynet>\n  <pkg/>\n</rubynet>\n"
-    @doc.root = XML::Node.new('rubynet')
-    @doc.root.child = XML::Node.new('pkg')
-    assert_equal(xml, @doc.to_s)
-  end
+  def test_to_s_encoding
+    # Test encodings
 
-  def test_append
-    xml = "<?xml version=\"1.0\"?>\n"
-    xml << "<rubynet>\n"
-    xml << "  <pkg>\n"
-    xml << "    <meta>\n"
-    xml << "      <pkgname>libxml</pkgname>\n"
-    xml << "    </meta>\n"
-    xml << "  </pkg>\n"
-    xml << "</rubynet>\n"
-    
-    @doc.root = XML::Node.new('rubynet')
-    pkg = @doc.root.child = XML::Node.new('pkg')
-    meta = pkg.child = XML::Node.new('meta')
-    assert_equal(meta, meta << (pkgname = XML::Node.new('pkgname')))
-    pkgname << 'libxml'
-    assert_equal(xml, @doc.to_s)
-  end
+    # UTF8:
+    # ö - c3 b6 in hex, \303\266 in octal
+    # ü - c3 bc in hex, \303\274 in octal
+    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 @doc.to_s(:encoding => XML::Input::UTF_8))
 
-  def test_node_search_href
-    prefix = 'xlink'
-    uri = 'http://www.rubynet.org'
-    xml = "<?xml version=\"1.0\"?>\n"
-    xml << "<rubynet xmlns:#{prefix}=\"#{uri}\">\n"
-    xml << "  <pkg/>\n"
-    xml << "</rubynet>\n"
-    
-    @doc.root = XML::Node.new('rubynet')
-    @doc = XML::Parser.string(xml).parse
-    assert_equal(xml, @doc.to_s)
-    ns = @doc.root.search_href(uri)
-    assert_instance_of(XML::NS, ns)
-    assert_equal(uri, ns.href)
-    assert_equal(prefix, ns.prefix)
-  end
+    # ISO_8859_1:
+    # ö - f6 in hex, \366 in octal
+    # ü - fc in hex, \374 in octal
+    assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 @doc.to_s(:encoding => XML::Input::ISO_8859_1))
 
-  def test_sibling
-    xml = "<?xml version=\"1.0\"?>\n<rubynet>\n  <pkg/>\n  <pkg2/>\n</rubynet>\n"
 
-    @doc.root = XML::Node.new('rubynet')
-    child = @doc.root.child = XML::Node.new('pkg')
-    assert_instance_of(XML::Node, child)
-    child.sibling = XML::Node.new('pkg2')
-    assert_equal(xml, @doc.to_s)
+    # Invalid encoding
+    error = assert_raise(ArgumentError) do
+      @doc.to_s(:encoding => -9999)
+    end
+    assert_equal('Unknown encoding.', error.to_s)
   end
 
-  def test_set_doc_property
-    xml = "<?xml version=\"1.0\"?>\n"
-    xml << "<rubynet xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
-    xml << "  <pkg/>\n"
-    xml << "</rubynet>\n"
-    
-    @doc.root = XML::Node.new('rubynet')
-    @doc.root['xmlns:xlink'] = "http://www.w3.org/1999/xlink"
-    pkg = @doc.root.child = XML::Node.new('pkg')
-    assert_equal(xml, @doc.to_s)
+  # --- save tests -----
+  def test_save_utf8
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8.xml")
+
+    bytes = @doc.save(temp_filename)
+    assert_equal(271, bytes)
+
+    contents = File.read(temp_filename)
+    assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\">\n  <m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+               contents)
+  ensure
+    File.delete(temp_filename)
   end
 
-  def test_set_node_base
-    xml = "<?xml version=\"1.0\"?>\n"
-    xml << "<rubynet>\n"
-    xml << "  <pkg xml:base=\"http://www.rubynet.org/\"/>\n"
-    xml << "</rubynet>\n"
-    
-    @doc.root = XML::Node.new('rubynet')
-    pkg = @doc.root.child = XML::Node.new('pkg')
-    pkg.base = 'http://www.rubynet.org/'
-    assert_equal(xml, @doc.to_s)
+  def test_save_utf8_no_indents
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_utf8_no_indents.xml")
+
+    bytes = @doc.save(temp_filename, :indent => false)
+    assert_equal(264, bytes)
+
+    contents = File.read(temp_filename)
+    assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<bands genre=\"metal\"><m\303\266tley_cr\303\274e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\303\266tley_cr\303\274e><iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+               contents)
+  ensure
+    File.delete(temp_filename)
   end
 
-  def test_set_node_property
-    xml = "<?xml version=\"1.0\"?>\n"
-    xml << "<rubynet xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n"
-    xml << "  <pkg version=\"1.0\">\n"
-    xml << "    <meta>\n"
-    xml << "      <pkgname>libxml</pkgname>\n"
-    xml << "    </meta>\n"
-    xml << "  </pkg>\n"
-    xml << "</rubynet>\n"
-    
-    @doc.root = XML::Node.new('rubynet')
-    @doc.root['xmlns:xlink'] = "http://www.w3.org/1999/xlink"
-    pkg = @doc.root.child = XML::Node.new('pkg')
-    pkg['version'] = '1.0'
-    meta = pkg.child = XML::Node.new('meta')
-    pkgname = meta.child = XML::Node.new('pkgname', 'libxml')
-    assert_equal(xml, @doc.to_s)
+  def test_save_iso_8859_1
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1.xml")
+    bytes = @doc.save(temp_filename, :encoding => XML::Input::ISO_8859_1)
+    assert_equal(272, bytes)
+
+    contents = File.read(temp_filename)
+    assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\">\n  <m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e>\n  <iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden>\n</bands>\n",
+                 contents)
+  ensure
+    File.delete(temp_filename)
   end
 
-  def test_encoding_utf
-    @doc.root = XML::Node.new('rubynet')
-    @doc.encoding = XML::Input.encoding_to_s(XML::Input::UTF8)
-    assert_instance_of(XML::Node, @doc.root)
-    assert_equal("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<rubynet/>\n", @doc.to_s)
+  def test_save_iso_8859_1_no_indent
+    temp_filename = File.join(Dir.tmpdir, "tc_document_write_test_save_iso_8859_1_no_indent.xml")
+    bytes = @doc.save(temp_filename, :indent => false, :encoding => XML::Input::ISO_8859_1)
+    assert_equal(265, bytes)
+
+    contents = File.read(temp_filename)
+    assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<bands genre=\"metal\"><m\366tley_cr\374e country=\"us\">An American heavy metal band formed in Los Angeles, California in 1981.</m\366tley_cr\374e><iron_maiden country=\"uk\">British heavy metal band formed in 1975.</iron_maiden></bands>\n",
+                 contents)
+  ensure
+    File.delete(temp_filename)
   end
 
-  def test_encoding_latin1
-    @doc.root = XML::Node.new('rubynet')
-    @doc.encoding = XML::Input.encoding_to_s(XML::Input::ISO_8859_1)
-    assert_instance_of(XML::Node, @doc.root)
-    assert_equal("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n<rubynet/>\n", @doc.to_s)
+  # --- Debug ---
+  def test_debug
+    assert(@doc.debug)
   end
-end
+end

data/test/tc_namespace.rb

@@ -0,0 +1,59 @@
+require "xml"
+require 'test/unit'
+
+class TestNS < Test::Unit::TestCase
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_create_ns
+    node = XML::Node.new('foo')
+    ns = XML::Namespace.new(node, 'my_namepace', 'http://www.mynamespace.com')
+    assert_equal(ns.prefix, 'my_namepace')
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+
+  def test_create_default_ns
+    node = XML::Node.new('foo')
+    ns = XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
+    assert_equal(ns.prefix, nil)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+
+  def test_create_unbound_ns
+    error = assert_raise(TypeError) do
+      XML::Namespace.new(nil, 'my_namepace', 'http://www.mynamespace.com')
+    end
+    assert_equal('wrong argument type nil (expected Data)', error.to_s)
+  end
+
+  def test_duplicate_ns
+    node = XML::Node.new('foo')
+    XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    assert_raises(XML::Error) do
+      XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    end
+  end
+
+  def test_eql
+    node = XML::Node.new('Envelope')
+    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert(node.namespaces.namespace.eql?(node.namespaces.namespace))
+  end
+
+  def test_equal
+    node1 = XML::Node.new('Envelope')
+    ns1 = XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    node2 = XML::Node.new('Envelope')
+    ns2 = XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert(ns1 == ns2)
+  end
+end

data/test/tc_namespaces.rb

@@ -0,0 +1,174 @@
+require "xml"
+require 'test/unit'
+
+class TestNamespaces < Test::Unit::TestCase
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_namespace
+    node = @doc.root
+    ns = node.namespaces.namespace
+    assert_equal('soap', ns.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', ns.href)
+  end
+
+  def test_set_namespace
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    ns = XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+
+    # Now put the node in the soap namespace
+    node.namespaces.namespace = ns
+    assert_not_nil(node.namespaces.namespace)
+    assert_equal("<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+  end
+
+  def test_define_namespace
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    XML::Namespace.new(node, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_define_default_namespace
+    node = XML::Node.new('Envelope')
+    assert_equal('<Envelope/>', node.to_s)
+
+    XML::Namespace.new(node, nil, 'http://schemas.xmlsoap.org/soap/envelope/')
+    assert_equal("<Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\"/>", node.to_s)
+    # This seems wrong, but appears to be the way libxml works
+    assert_nil(node.namespaces.namespace)
+  end
+
+  def test_namespaces
+    node = @doc.find_first('//ns1:IdAndName',
+                           :ns1 => 'http://domain.somewhere.com')
+
+    namespaces = node.namespaces.sort
+    assert_equal(5, namespaces.length)
+
+    namespace = namespaces[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+
+    namespace = namespaces[1]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('ns1', namespace.prefix)
+    assert_equal('http://domain.somewhere.com', namespace.href)
+
+    namespace = namespaces[2]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = namespaces[3]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = namespaces[4]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+  end
+
+  def test_namespaces
+    node = @doc.find_first('//ns1:IdAndName',
+                           :ns1 => 'http://domain.somewhere.com')
+
+    namespaces = node.namespaces.each do |namespace|
+      assert_instance_of(XML::Namespace, namespace)
+    end
+  end
+
+  def test_namespace_definitions
+    ns_defs = @doc.root.namespaces.definitions
+    assert_equal(3, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+
+    namespace = ns_defs[1]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsd', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema', namespace.href)
+
+    namespace = ns_defs[2]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('xsi', namespace.prefix)
+    assert_equal('http://www.w3.org/2001/XMLSchema-instance', namespace.href)
+
+    node = @doc.root.find_first('//ns:getManufacturerNamesResponse',
+                                :ns => 'http://services.somewhere.com')
+    ns_defs = node.namespaces.definitions
+    assert_equal(1, ns_defs.size)
+
+    namespace = ns_defs[0]
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_by_prefix
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+
+    namespace = @doc.root.namespaces.find_by_prefix('soap')
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_find_default_ns
+    namespace = @doc.root.namespaces.find_by_prefix(nil)
+    assert_nil(namespace)
+
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+    namespace = node.namespaces.find_by_prefix(nil)
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal(nil, namespace.prefix)
+    assert_equal('http://services.somewhere.com', namespace.href)
+  end
+
+  def test_find_ns_by_href
+    node = @doc.find_first('//ns1:getManufacturerNamesResponse',
+                           :ns1 => 'http://services.somewhere.com')
+
+    namespace = node.namespaces.find_by_href('http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert_instance_of(XML::Namespace, namespace)
+    assert_equal('soap', namespace.prefix)
+    assert_equal('http://schemas.xmlsoap.org/soap/envelope/', namespace.href)
+  end
+
+  def test_default_namespace
+    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    ns = doc.root.namespaces.default
+    assert_equal(ns.href, 'http://schemas.xmlsoap.org/soap/envelope/')
+  end
+
+  def test_default_prefix
+    doc = XML::Document.string('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/"/>')
+    doc.root.namespaces.default_prefix = 'soap'
+
+    node = doc.root.find_first('/soap:Envelope')
+    assert_not_nil(node)
+  end
+end