libxml-ruby 2.8.0 → 3.2.1

data/test/{tc_encoding_sax.rb → test_encoding_sax.rb}

@@ -1,12 +1,13 @@
 # encoding: UTF-8
-require './test_helper'
-require 'test/unit'
+require_relative './test_helper'
 
 class SaxEncodingCallbacks
   attr_reader :encoding
-  include Test::Unit::Assertions
+  attr_accessor :assertions
+  include Minitest::Assertions
 
   def initialize
+    @assertions = 0
     @encoding = Encoding::UTF_8
   end
 
@@ -90,7 +91,7 @@ class SaxEncodingCallbacks
   end
 end
 
-class TestEncodingSax < Test::Unit::TestCase
+class TestEncodingSax < Minitest::Test
   def setup
     Encoding.default_internal = nil
   end
@@ -101,13 +102,13 @@ class TestEncodingSax < Test::Unit::TestCase
   end
 
   def test_encoding_iso_8859_1
-    parser = XML::SaxParser.file(file_for_encoding(Encoding::ISO_8859_1))
+    parser = LibXML::XML::SaxParser.file(file_for_encoding(Encoding::ISO_8859_1))
     parser.callbacks = SaxEncodingCallbacks.new
     parser.parse
   end
 
   def test_encoding_utf8
-    parser = XML::SaxParser.file(file_for_encoding(Encoding::UTF_8))
+    parser = LibXML::XML::SaxParser.file(file_for_encoding(Encoding::UTF_8))
     parser.callbacks = SaxEncodingCallbacks.new
     parser.parse
   end

data/test/test_error.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class TestError < Minitest::Test
+  # def test_error_codes
+  #   assert_equal(4, LibXML::XML::Error::DTD)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DTD'))
+  #
+  #   assert_equal(4, LibXML::XML::Error::DOCUMENT_EMPTY)
+  #   assert_equal(4, LibXML::XML::Error.const_get('DOCUMENT_EMPTY'))
+  # end
+  #
+  # def test_invalid_handler
+  #   assert_raises(RuntimeError) do
+  #     LibXML::XML::Error.set_handler
+  #   end
+  # end
+  #
+  # def test_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   # Raise the error
+  #   error = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Reader.string('<foo').read
+  #   end
+  #   assert_equal(exception, error)
+  #
+  #   # Check the handler worked
+  #   refute_nil(exception)
+  #   assert_kind_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Couldn't find end of Start Tag foo at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::GT_REQUIRED, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  #   assert_equal('foo', exception.str1)
+  #   assert_nil(exception.str2)
+  #   assert_nil(exception.str3)
+  #   assert_equal(0, exception.int1)
+  #   assert_equal(5, exception.int2)
+  #   assert_nil(exception.node)
+  # end
+  #
+  # def test_reset_handler
+  #   exception = nil
+  #   LibXML::XML::Error.set_handler do |error|
+  #     exception = error
+  #   end
+  #
+  #   LibXML::XML::Error.reset_handler
+  #   LibXML::XML::Reader.string('<foo')
+  #   assert_nil(exception)
+  # end
+  #
+  # def test_get_handler
+  #   assert_respond_to(LibXML::XML::Error, :get_handler)
+  #   assert_equal(0, LibXML::XML::Error.method(:get_handler).arity)
+  #
+  #   saved_handler = LibXML::XML::Error.get_handler
+  #   LibXML::XML::Error.set_handler{ puts "New handler" }
+  #   refute_equal(LibXML::XML::Error.get_handler, saved_handler)
+  #
+  #   LibXML::XML::Error.set_handler(&saved_handler)
+  #   assert_equal(LibXML::XML::Error.get_handler, saved_handler)
+  # end
+  #
+  # def test_verbose_handler
+  #   LibXML::XML::Error.set_handler(&LibXML::XML::Error::VERBOSE_HANDLER)
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.\n", output.string)
+  # end
+  #
+  # def test_no_hanlder
+  #   LibXML::XML::Error.reset_handler
+  #   output = StringIO.new
+  #   original_stderr = Object::STDERR
+  #
+  #   Object.const_set(:STDERR, output)
+  #   begin
+  #     assert_raises(LibXML::XML::Error) do
+  #       LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #     end
+  #   ensure
+  #     Object.const_set(:STDERR, original_stderr)
+  #   end
+  #   assert_equal('', output.string)
+  # end
+  #
+  # def test_parse_error
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo><bar/></foz>').parse
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Fatal error: Opening and ending tag mismatch: foo line 1 and foz at :1.", exception.message)
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal(LibXML::XML::Error::TAG_NAME_MISMATCH, exception.code)
+  #   assert_equal(LibXML::XML::Error::FATAL, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_equal(1, exception.line)
+  # end
+  #
+  # def test_xpath_error
+  #   doc = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/soap.xml'))
+  #
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     doc.find('/foo[bar=test')
+  #   end
+  #
+  #   assert_instance_of(LibXML::XML::Error, exception)
+  #   assert_equal("Error: Invalid predicate.", exception.message)
+  #   assert_equal(LibXML::XML::Error::XPATH, exception.domain)
+  #   assert_equal(LibXML::XML::Error::XPATH_INVALID_PREDICATE_ERROR, exception.code)
+  #   assert_equal(LibXML::XML::Error::ERROR, exception.level)
+  #   assert_nil(exception.file)
+  #   assert_nil(nil)
+  # end
+
+  def test_double_parse
+    LibXML::XML::Parser.register_error_handler(lambda {|msg| nil })
+    parser = LibXML::XML::Parser.string("<test>something</test>")
+    parser.parse
+
+    error = assert_raises(LibXML::XML::Error) do
+      # Try parsing a second time
+      parser.parse
+    end
+
+    assert_equal(" LibXML::XML::Error.", error.to_s)
+  end
+
+  # def test_libxml_parser_empty_string
+  #   xp = LibXML::XML::Parser.new
+  #
+  #   error = assert_raises(TypeError) do
+  #     xp.string = nil
+  #   end
+  #   assert_equal('wrong argument type nil (expected String)', error.to_s)
+  #
+  #   error = assert_raises(ArgumentError) do
+  #     xp.string = ''
+  #   end
+  #   assert_equal('Must specify a string with one or more characters', error.to_s)
+  # end
+  #
+  # def test_error_domain_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #
+  #   assert_equal(LibXML::XML::Error::PARSER, exception.domain)
+  #   assert_equal("PARSER",exception.domain_to_s)
+  # end
+  #
+  # def test_error_code_to_s
+  #   exception = assert_raises(LibXML::XML::Error) do
+  #     LibXML::XML::Parser.string('<foo href="http://example.org/cgi?k1=v1&k2=v2"></foo>').parse
+  #   end
+  #   assert_equal(LibXML::XML::Error::ENTITYREF_SEMICOL_MISSING, exception.code)
+  #   assert_equal("ENTITYREF_SEMICOL_MISSING",exception.code_to_s)
+  # end
+end

data/test/test_helper.rb

@@ -2,13 +2,6 @@
 
 # To make testing/debugging easier, test within this source tree versus an installed gem
 
-dir = File.dirname(__FILE__)
-root = File.expand_path(File.join(dir, '..'))
-lib = File.expand_path(File.join(root, 'lib'))
-ext = File.expand_path(File.join(root, 'ext', 'libxml'))
-
-$LOAD_PATH << lib
-$LOAD_PATH << ext
-
-require 'xml'
-
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'libxml-ruby'

data/test/test_html_parser.rb

@@ -0,0 +1,162 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+require 'stringio'
+
+class HTMLParserTest < Minitest::Test
+  def html_file
+    File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
+  end
+
+  # -----  Sources  ------
+  def test_file
+    xp = LibXML::XML::HTMLParser.file(html_file)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+    doc = xp.parse
+    refute_nil(doc)
+  end
+
+  def test_noexistent_file
+    error = assert_raises(LibXML::XML::Error) do
+      LibXML::XML::HTMLParser.file('i_dont_exist.xml')
+    end
+
+    assert_equal('Warning: failed to load external entity "i_dont_exist.xml".', error.to_s)
+  end
+
+  def test_nil_file
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.file(nil)
+    end
+
+    assert_match(/nil into String/, error.to_s)
+  end
+
+  def test_io
+    File.open(html_file) do |io|
+      xp = LibXML::XML::HTMLParser.io(io)
+      assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+      doc = xp.parse
+      assert_instance_of(LibXML::XML::Document, doc)
+    end
+  end
+
+  def test_io_gc
+    # Test that the reader keeps a reference
+    # to the io object
+    file = File.open(html_file)
+    parser = LibXML::XML::HTMLParser.io(file)
+    file = nil
+    GC.start
+    assert(parser.parse)
+  end
+
+  def test_nil_io
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.io(nil)
+    end
+
+    assert_equal("Must pass in an IO object", error.to_s)
+  end
+
+  def test_string_io
+    data = File.read(html_file)
+    io = StringIO.new(data)
+    xp = LibXML::XML::HTMLParser.io(io)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+  end
+
+  def test_string
+    str = '<html><body><p>hi</p></body></html>'
+    xp = LibXML::XML::HTMLParser.string(str)
+
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+    assert_instance_of(LibXML::XML::HTMLParser, xp)
+
+    doc = xp.parse
+    assert_instance_of(LibXML::XML::Document, doc)
+  end
+
+  def test_nil_string
+    error = assert_raises(TypeError) do
+      LibXML::XML::HTMLParser.string(nil)
+    end
+
+    assert_equal("wrong argument type nil (expected String)", error.to_s)
+  end
+
+  def test_parse
+    html = <<-EOS
+      <html>
+        <head>
+          <meta name=keywords content=nasty>
+        </head>
+        <body>Hello<br>World</html>
+   EOS
+
+    parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOBLANKS)
+    doc = parser.parse
+    assert_instance_of LibXML::XML::Document, doc
+
+    root = doc.root
+    assert_instance_of LibXML::XML::Node, root
+    assert_equal 'html', root.name
+
+    head = root.child
+    assert_instance_of LibXML::XML::Node, head
+    assert_equal 'head', head.name
+
+    meta = head.child
+    assert_instance_of LibXML::XML::Node, meta
+    assert_equal 'meta', meta.name
+    assert_equal 'keywords', meta[:name]
+    assert_equal 'nasty', meta[:content]
+
+    body = head.next
+    assert_instance_of LibXML::XML::Node, body
+    assert_equal 'body', body.name
+
+    hello = body.child
+    # It appears that some versions of libxml2 add a layer of <p>
+    # cant figure our why or how, so this skips it if there
+    hello = hello.child if hello.name == "p"
+
+    assert_instance_of LibXML::XML::Node, hello
+    assert_equal 'Hello', hello.content
+
+    br = hello.next
+    assert_instance_of LibXML::XML::Node, br
+    assert_equal 'br', br.name
+
+    world = br.next
+    assert_instance_of LibXML::XML::Node, world
+    assert_equal 'World', world.content
+  end
+
+  def test_no_implied
+    html = "hello world"
+    parser = LibXML::XML::HTMLParser.string(html, :options => LibXML::XML::HTMLParser::Options::NOIMPLIED)
+    doc = parser.parse
+    assert_equal("<p>#{html}</p>", doc.root.to_s)
+  end
+
+  def test_comment
+    doc = LibXML::XML::HTMLParser.string('<!-- stuff -->', :options => LibXML::XML::HTMLParser::Options::NOIMPLIED |
+                                                                       LibXML::XML::HTMLParser::Options::NOERROR |
+                                                                       LibXML::XML::HTMLParser::Options::NOWARNING |
+                                                                       LibXML::XML::HTMLParser::Options::RECOVER |
+                                                                       LibXML::XML::HTMLParser::Options::NONET)
+    assert(doc)
+  end
+
+  def test_open_many_files
+    file = File.expand_path(File.join(File.dirname(__FILE__), 'model/ruby-lang.html'))
+    1000.times do
+      LibXML::XML::HTMLParser.file(file).parse
+    end
+  end
+end

data/test/test_html_parser_context.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestHtmlParserContext < Minitest::Test
+  def test_default_options
+    context = LibXML::XML::HTMLParser::Context.new
+    assert_equal(0, context.options)
+  end
+
+  def test_no_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = 0
+    assert_equal(0, context.options)
+  end
+
+  def test_options
+    context = LibXML::XML::HTMLParser::Context.new
+    context.options = LibXML::XML::HTMLParser::Options::NOERROR
+    assert_equal(LibXML::XML::HTMLParser::Options::NOERROR, context.options)
+  end
+end

data/test/test_namespace.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require_relative './test_helper'
+
+
+class TestNS < Minitest::Test
+  def setup
+    file = File.join(File.dirname(__FILE__), 'model/soap.xml')
+    @doc = LibXML::XML::Document.file(file)
+  end
+
+  def teardown
+    @doc = nil
+  end
+
+  def test_create_ns
+    node = LibXML::XML::Node.new('foo')
+    ns = LibXML::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 = LibXML::XML::Node.new('foo')
+    ns = LibXML::XML::Namespace.new(node, nil, 'http://www.mynamespace.com')
+    assert_nil(ns.prefix)
+    assert_equal(ns.href, 'http://www.mynamespace.com')
+  end
+
+  def test_create_unbound_ns
+    error = assert_raises(TypeError) do
+      LibXML::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 = LibXML::XML::Node.new('foo')
+    LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    assert_raises(LibXML::XML::Error) do
+      LibXML::XML::Namespace.new(node, 'myname', 'http://www.mynamespace.com')
+    end
+  end
+
+  def test_eql
+    node = LibXML::XML::Node.new('Envelope')
+
+    assert(node.namespaces.namespace.eql?(node.namespaces.namespace))
+  end
+
+  def test_equal
+    node1 = LibXML::XML::Node.new('Envelope')
+    ns1 = LibXML::XML::Namespace.new(node1, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    node2 = LibXML::XML::Node.new('Envelope')
+    ns2 = LibXML::XML::Namespace.new(node2, 'soap', 'http://schemas.xmlsoap.org/soap/envelope/')
+
+    assert(ns1 == ns2)
+  end
+end