testunitxml 0.1.3

data/lib/test/unit/xml/xml_assertions.rb

@@ -0,0 +1,187 @@
+#! /usr/bin/ruby
+
+require 'rexml/document'
+require 'test/unit/xml/attributes_mixin' # Must be required after rexml/document
+require 'test/unit'
+require 'test/unit/xml/xmlequalfilter'
+require 'test/unit/xml/nodeiterator'
+
+=begin rdoc
+This module contains assertions about XML documents. The assertions are
+meant to be mixed in to test classes such as Test::Unit::TestCase.
+=end
+module Test
+  module Unit
+    module XML
+
+      # This method checks whether two well-formed XML documents are equal.
+      # Doctype declarations are ignored for the purposes of comparison.
+      # Two XML documents are considered equal if:
+      # * They contain the same type of nodes, in the same order,
+      #   except for text nodes that are empty, or contain only
+      #   whitespace. Such text nodes are ignored.
+      # * The corresponding nodes in the two documents are equal.
+      #
+      # Nodes are tested for equality as follows:
+      # XML Declarations::
+      #      XML declarations are equal if they have the same version,
+      #      encoding, and stand-alone pseudo-attributes.
+      # Doctype::
+      #      Doctype declarations are ignored.
+      # Elements::
+      #      Elements are considered equal if they have the same generic
+      #      identifier (tag name) and belong to the same namespace. The
+      #      namespace _prefixes_ may be different.
+      # Attributes::
+      #      Attributes are equal if they belong to the same namespace,
+      #      have the same name, and the same value.
+      # Namespace Declarations::
+      #      Namespace _declarations_ (attributes named <tt>xmlns:<em>prefix</em></tt>)
+      #      are ignored. There are several reasons for this:
+      #      - As long as two elements or attributes
+      #        belong to the same namespace, it does not matter what prefixes
+      #        are used. XML processors may also change prefixes in unpredictable
+      #        ways without this being an error.
+      #      - XML processors may _move_ namespace
+      #        declarations from one element to another (usually an ancestor,
+      #        sometimes a descendant) without this being an error, or under
+      #        control by the programmer.
+      #      - XML processors may _add_ extraneous namespace declarations
+      #        in a manner that is hard for programmers to control.
+      # Processing Instructions::
+      #      Processing instructions are considered equal if the string
+      #      values of their targets and contents are equal.
+      # Text::
+      #      Text nodes are equal if their values are equal. However, empty
+      #      text nodes, and text nodes containing only whitespace are ignored.
+      # CDATA::
+      #      CDATA nodes are equal if their text content is equal. Whitespace
+      #      is _not_ normalized.
+      # Comments::
+      #      Comments are equal if they have the same content.
+      #
+      # The +expected_doc+ and +actual_doc+ arguments to this method may be of
+      # the following types:
+      # * A +REXML+ node, usually a <tt>REXML::Document</tt> or <tt>REXML::Element</tt>
+      # * A +File+ or other +IO+ object representing an XML document
+      # * A string containing an XML document
+      def assert_xml_equal(expected_doc, actual_doc, message = nil)
+        expected_doc = parse_xml(expected_doc)
+        actual_doc = parse_xml(actual_doc)
+        _wrap_assertion do
+          full_message = build_message(message, <<EOT, actual_doc.inspect, expected_doc.inspect)
+
+<?> expected to be equal to
+<?> but was not.
+EOT
+          assert_block(full_message){are_equal?(expected_doc, actual_doc)}
+        end
+      end
+      
+      private
+      
+      def parse_xml(xml)
+        case xml
+        when IO
+          REXML::Document.new(xml)
+        when String
+          REXML::Document.new(xml)
+        else
+          xml
+        end
+      end
+      
+      def are_equal?(expected_doc, actual_doc)
+        iterate(expected_doc, actual_doc) do |expected_node, actual_node|
+          unless compare_xml_nodes(expected_node, actual_node)
+            return false
+          end
+        end
+        true
+      end
+      
+      def iterate(expected_doc, actual_doc)
+        filter = Test::Unit::XML::XmlEqualFilter.new()
+        expected_iterator = NodeIterator.new(expected_doc, filter)
+        actual_iterator = NodeIterator.new(actual_doc, filter)
+        while expected_iterator.has_next()
+          expected_node = expected_iterator.next()
+          actual_node = actual_iterator.next()
+          yield expected_node, actual_node
+        end
+      end
+      
+      def compare_xml_nodes(expected_node, actual_node)
+        return false unless actual_node.instance_of? expected_node.class
+        case actual_node
+        when REXML::Document
+          # TODO: Implement Document comparison
+          true
+        when REXML::DocType
+          # TODO: Implement DOCTYPE comparison
+          true
+        when REXML::Element :
+          compare_elements(expected_node, actual_node)
+        when REXML::CData
+          compare_texts(expected_node, actual_node)
+        when REXML::Text
+          compare_texts(expected_node, actual_node)
+        when REXML::Comment
+          compare_comments(expected_node, actual_node)
+        when REXML::Instruction
+          compare_pi(expected_node, actual_node)
+        when REXML::XMLDecl
+          compare_xml_declaration(expected_node, actual_node)
+        else
+          puts "Unknown node type #{actual_node.class}"
+          false
+        end
+      end
+      
+      def compare_elements(expected_node, actual_node)
+        return  expected_node.name == actual_node.name &&
+                expected_node.namespace() == actual_node.namespace() &&
+                compare_attributes(expected_node.attributes, actual_node.attributes)
+      end
+            
+      def compare_attributes(expected_attributes, actual_attributes)
+        return false unless attribute_count(expected_attributes) == attribute_count(actual_attributes)
+        expected_attributes.each_attribute do |expected_attribute|
+          expected_prefix = expected_attribute.prefix()
+          unless expected_prefix == 'xmlns' then
+            expected_name = expected_attribute.name
+            expected_namespace = expected_attribute.namespace
+            actual_attribute = actual_attributes.get_attribute_ns(expected_namespace, expected_name)
+            return false unless actual_attribute
+            return false if expected_attribute != actual_attribute
+          end
+        end
+        true
+      end
+      
+      def attribute_count(attributes)
+        # Do not count namespace declarations
+        attributes.size - attributes.prefixes.size
+      end
+          
+      def compare_texts(expected_node, actual_node)
+        expected_node.value.eql?(actual_node.value)
+      end  
+      
+      def compare_comments(expected_node, actual_node)
+        expected_node == actual_node
+      end
+      
+      def compare_pi(expected_pi, actual_pi)
+        return expected_pi.target == actual_pi.target &&
+               expected_pi.content == actual_pi.content
+      end
+      
+      def compare_xml_declaration(expected_decl, actual_decl)
+        return expected_decl == actual_decl
+      end
+      
+    end      
+  end
+end
+

data/lib/test/unit/xml/xmlequalfilter.rb

@@ -0,0 +1,27 @@
+#! /usr/bin/ruby
+
+module Test
+  module Unit
+    module XML
+      
+      # This filter class accepts any node except text nodes
+      # that contain non-significant whitespace
+      class XmlEqualFilter
+        def accept(node)
+          case
+          when node.kind_of?(REXML::Text)
+            is_significant?(node.value)
+          else
+            true
+          end
+        end
+        
+        private
+        
+        def is_significant?(string)
+          string =~ /^\s*$/ ? false : true
+        end
+      end
+    end
+  end
+end

data/test/data/test1.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" standalone="yes" encoding="utf-8"?>
+<book xmlns="http://www.henrikmartensson.org/ns/testunitxml/test1">
+	<chapter id="a" type="">
+		<title>First Chapter</title>
+		<p>This <em type="medium">is</em> the first chapter.</p>
+		<section>
+			<title>First Chapter, First Section</title>
+			<?pi1?>
+			<?pi2 content?>
+			<?pi3 more content?>
+		</section>
+	</chapter>
+	<chapter id="b" type="" xmlns="http://www.henrikmartensson.org/ns/testunitxml/test2">
+		<title>Second Chapter</title>
+		<p>This is the second chapter.</p>
+		<t3:section xmlns:t3="http://www.henrikmartensson.org/ns/testunitxml/test3">
+			<t3:title>Second Chapter, Second Section</t3:title>
+			<p><![CDATA[This is a 
+			
+			CDATA section.]]></p>
+		</t3:section>
+	</chapter>
+</book>

data/test/tc_testunitxml.rb

@@ -0,0 +1,123 @@
+#! /usr/bin/ruby
+
+@@lib_path = File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift @@lib_path 
+
+require 'test/unit/xml'
+require 'rexml/document'
+require 'stringio'
+
+class TestTestUnitXml < Test::Unit::TestCase
+  TEST_1_PATH = "test/data/test1.xml"
+    
+  def setup
+    @file = File.new(TEST_1_PATH)
+    @doc1 = REXML::Document.new(@file)
+    @io1 = File.new(TEST_1_PATH)
+    @io2 = File.new(TEST_1_PATH)
+    @string1 = %Q{<t:root xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" id="a" t:type="test1"/>}
+    @element1 = REXML::Document.new(%Q{<t:root xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" id="a" t:type="test1"/>}).root
+    @element2 = REXML::Document.new(%Q{<root xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" id="a" t:type="test1"/>}).root
+    @element3 = REXML::Document.new(%Q{<t:root xmlns:t="urn:x-hm:other" xmlns:x="urn:x-hm:test2" id="a" t:type="test1"/>}).root
+    @element4 = REXML::Document.new(%Q{<t:root xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" id="a" x:type="test1"/>}).root
+    @element5 = REXML::Document.new(%Q{<t:root xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" id="a" t:type="test2"/>}).root
+    @element6 = REXML::Document.new(%Q{<t:root  id="a" xmlns:t="urn:x-hm:test" xmlns:x="urn:x-hm:test2" t:type="test1"/>}).root
+    @element7 = REXML::Document.new(%Q{<s:root xmlns:s="urn:x-hm:test" xmlns:x="urn:x-hm:test" id="a" s:type="test1"/>}).root
+    @element8 = REXML::Document.new(%Q{<t:root xmlns:t="urn:x-hm:test" id="a" t:type="test1"/>}).root
+    @text1 = REXML::Text.new(" Q")
+    @text2 = REXML::Text.new("  &#81;")
+    @text3 = REXML::Text.new("  Q ")
+    @cdata1 = REXML::CData.new("Test text")
+    @cdata2 = REXML::CData.new("Test \ntext")
+    @comment1 = REXML::Comment.new("This is a comment.")
+    @comment2 = REXML::Comment.new("This is another comment.")
+    @pi1 = REXML::Instruction.new('pi1', 'content')
+    @pi2 = REXML::Instruction.new('pi2', 'content')
+    @pi3 = REXML::Instruction.new('pi1', 'other content')
+    @whitespace1 = REXML::Document.new(%Q{<r><a>Some <b>text</b>.</a></r>})
+    @whitespace2 = REXML::Document.new(%Q{<r> <a>Some <b>text</b>.</a>\n  \n  </r>})
+    @whitespace3 = REXML::Document.new(%Q{<r><a>Some <b> text</b>.</a></r>})
+    # REXML:XMLDecl.new(version=DEFAULT_VERSION, encoding=nil, standalone=nil)   
+    @xml_decl1 = REXML::XMLDecl.new(1.0, "utf-8", "yes")
+    @xml_decl2 = REXML::XMLDecl.new(1.1, "utf-8", "yes")
+    @xml_decl3 = REXML::XMLDecl.new(1.0, "utf-16", "yes")
+    @xml_decl4 = REXML::XMLDecl.new(1.0, "utf-8", "no")   
+  end
+  
+  def teardown
+  end
+    
+  def test_assert_xml_equal_document
+    assert_xml_equal(@doc1, @doc1, "Comparing two REXML::Document objects")
+  end
+  
+  def test_assert_xml_equal_io
+    assert_xml_equal(@io1, @io2, "Comparing two IO objects")
+  end
+
+  def test_assert_xml_equal_string
+    assert_xml_equal(@string1, @string1, "Comparing two XML strings")
+  end
+  
+  def test_assert_xml_equal_element
+    assert_instance_of(REXML::Element, @element1)
+    assert_xml_equal(@element1, @element1)
+    check_assertion_failure(@element1, @element2)
+    check_assertion_failure(@element1, @element3)
+    check_assertion_failure(@element1, @element4)
+    check_assertion_failure(@element1, @element5)
+    assert_xml_equal(@element1, @element6)
+    assert_xml_equal(@element1, @element7)
+    assert_xml_equal(@element1, @element8)
+  end
+  
+  def check_assertion_failure(expected, actual)
+    assert_raise(Test::Unit::AssertionFailedError) {
+      assert_xml_equal(expected, actual)
+    }
+  end
+  
+  def test_assert_xml_equal_text
+    assert_instance_of(REXML::Text, @text1)
+    assert_instance_of(REXML::Text, @text1)
+    assert_xml_equal(@text1, @text1)
+    assert_xml_equal(@text1, @text2)
+    check_assertion_failure(@text1, @text3)
+  end
+  
+  def test_assert_xml_equal_cdata
+    assert_instance_of(REXML::CData, @cdata1)
+    assert_instance_of(REXML::CData, @cdata2)
+    assert_xml_equal(@cdata1, @cdata1)
+    check_assertion_failure(@cdata1, @cdata2)
+  end
+  
+  def test_assert_xml_equal_comment
+    assert_instance_of(REXML::Comment, @comment1)
+    assert_instance_of(REXML::Comment, @comment2)
+    assert_xml_equal(@comment1, @comment1)
+    check_assertion_failure(@comment1, @comment2)
+  end
+
+  def test_assert_xml_equal_pi
+    assert_instance_of(REXML::Instruction, @pi1)
+    assert_instance_of(REXML::Instruction, @pi2)
+    assert_instance_of(REXML::Instruction, @pi3)
+    assert_xml_equal(@pi1, @pi1)
+    check_assertion_failure(@pi1, @pi2)
+    check_assertion_failure(@pi1, @pi3)
+  end
+  
+  def test_assert_xml_equal_whitespace
+    assert_xml_equal(@whitespace1, @whitespace1)
+    assert_xml_equal(@whitespace1, @whitespace2, "Check if extraneous whitespace is skipped")
+    check_assertion_failure(@whitespace1, @whitespace3)
+  end
+  
+  def test_assert_xml_equal_xmldecl
+    assert_instance_of(REXML::XMLDecl, @xml_decl1)
+    assert_xml_equal(@xml_decl1, @xml_decl1)
+    check_assertion_failure(@xml_decl1, @xml_decl2)
+  end
+    
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: testunitxml
+version: !ruby/object:Gem::Version 
+  version: 0.1.3
+date: 2006-01-11 00:00:00 +01:00
+summary: Unit test suite for XML documents
+require_paths: 
+- lib
+email: self@henrikmartensson.org
+homepage: http://testunitxml.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: test/unit/xml
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Henrik Martensson
+files: 
+- docs/html
+- docs/html/created.rid
+- docs/html/files
+- docs/html/classes
+- docs/html/fr_file_index.html
+- docs/html/fr_class_index.html
+- docs/html/fr_method_index.html
+- docs/html/index.html
+- docs/html/files/README.html
+- docs/html/files/MIT-LICENSE.html
+- docs/html/files/lib
+- docs/html/files/lib/test
+- docs/html/files/lib/test/unit
+- docs/html/files/lib/test/unit/xml_rb.html
+- docs/html/files/lib/test/unit/xml
+- docs/html/files/lib/test/unit/xml/xmlequalfilter_rb.html
+- docs/html/files/lib/test/unit/xml/nodeiterator_rb.html
+- docs/html/files/lib/test/unit/xml/attributes_mixin_rb.html
+- docs/html/files/lib/test/unit/xml/xml_assertions_rb.html
+- docs/html/classes/REXML
+- docs/html/classes/Test
+- docs/html/classes/REXML.html
+- docs/html/classes/Test.html
+- docs/html/classes/REXML/Attributes.src
+- docs/html/classes/REXML/Attributes.html
+- docs/html/classes/REXML/Attributes.src/M000001.html
+- docs/html/classes/Test/Unit
+- docs/html/classes/Test/Unit.html
+- docs/html/classes/Test/Unit/XML.src
+- docs/html/classes/Test/Unit/XML
+- docs/html/classes/Test/Unit/XML.html
+- docs/html/classes/Test/Unit/TestCase.html
+- docs/html/classes/Test/Unit/XML.src/M000002.html
+- docs/html/classes/Test/Unit/XML/NodeIterator.src
+- docs/html/classes/Test/Unit/XML/NodeIterator
+- docs/html/classes/Test/Unit/XML/XmlEqualFilter.src
+- docs/html/classes/Test/Unit/XML/NodeIterator.html
+- docs/html/classes/Test/Unit/XML/XmlEqualFilter.html
+- docs/html/classes/Test/Unit/XML/NodeIterator.src/M000003.html
+- docs/html/classes/Test/Unit/XML/NodeIterator.src/M000004.html
+- docs/html/classes/Test/Unit/XML/NodeIterator.src/M000005.html
+- docs/html/classes/Test/Unit/XML/NodeIterator.src/M000006.html
+- docs/html/classes/Test/Unit/XML/NodeIterator/NullNodeFilter.src
+- docs/html/classes/Test/Unit/XML/NodeIterator/NullNodeFilter.html
+- docs/html/classes/Test/Unit/XML/NodeIterator/NullNodeFilter.src/M000007.html
+- docs/html/classes/Test/Unit/XML/XmlEqualFilter.src/M000008.html
+- lib/test
+- lib/test/unit
+- lib/test/unit/xml
+- lib/test/unit/xml.rb
+- lib/test/unit/xml/xmlequalfilter.rb
+- lib/test/unit/xml/nodeiterator.rb
+- lib/test/unit/xml/attributes_mixin.rb
+- lib/test/unit/xml/xml_assertions.rb
+- test/data
+- test/tc_testunitxml.rb
+- test/data/test1.xml
+test_files: 
+- test/tc_testunitxml.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+