test_xml 0.0.1 → 0.0.2

data/README.rdoc

@@ -0,0 +1,123 @@
+= TestXml
+
+== DESCRIPTION:
+
+TestXml is a small extension for RSpec and TestUnit for XML/HTML testing. I have found it very useful for API testing with our Cucumber tests.
+
+== FEATURES:
+
+* test XML with: RSpec, Test::Unit, Cucumber
+* test XML structure (partially or fully matched)
+* test the element values within XML structure
+
+== EXAMPLES:
+
+=== Cucumber feature
+
+  Scenario:
+    Given data
+    When I post the data
+    The I receive successful response
+    And response matches the following xml
+    """
+      <transaction>
+        <status>success</status>
+        <id/>
+        <order_id/>
+      </transaction>
+    """
+
+The scenario will check:
+
+* 'status' element and its value.
+* 'id' and 'order_id' elements are present in XML
+
+== USAGE:
+
+=== RSpec
+
+in spec_helper.rb
+
+  require 'test_xml'
+  require 'test_xml/spec'
+
+in spec file:
+
+  it "should match_xml" do
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>2</two>
+      </root>
+    XML
+
+    xml.should match_xml(<<-XML)
+      <root>
+        <one>1</one>
+        <two>2</two>
+      </root>
+    XML
+  end
+
+=== Implemented matchers
+
+* match_xml
+* exactly_match_xml
+* match_xml_structure
+* exactly_match_xml_structure
+
+=== With Test::Unit
+
+in test_helper.rb
+
+  require 'test_xml'
+  require 'test_xml/test_unit'
+
+in test file:
+
+  def test_that_xml_matches
+    xml = <<-XML
+      <root>
+        <one>1</one>
+      </root>
+    XML
+
+    assert_match_xml(xml) do
+      <<-XML
+        <root>
+          <one>1</one>
+        </root>
+      XML
+    end
+  end
+
+=== Implemented assertions
+
+* assert_match_xml
+* assert_exactly_match_xml
+* assert_match_xml_structure
+* assert_exactly_match_xml_structure
+
+with assert_not_*
+
+=== With Cucumber
+
+Add to features/env.rb
+
+  require 'test_xml'
+  require 'test_xml/spec'
+  World(TestXml::Spec)
+
+And you can add the following step:
+
+  Then /^response matches the following xml$/ do |string|
+    response.body.should match_xml(string)
+  end
+
+== REQUIREMENTS
+
+test_xml depends on Nokogiri
+
+== INSTALL
+
+  [sudo] gem install test_xml

data/Rakefile

@@ -2,6 +2,7 @@ require 'rubygems'
 require 'rake'
 require 'rake/testtask'
 require 'spec/rake/spectask'
+require 'rdoc/task'
 
 task :default => ['test:units', :spec]
 
@@ -18,3 +19,8 @@ Spec::Rake::SpecTask.new do |t|
     t.libs << "spec"
     t.verbose = true
 end
+
+RDoc::Task.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end

data/lib/test_xml.rb

@@ -1,10 +1,6 @@
 require 'rubygems'
 require 'nokogiri'
 
-module TestXml
-  VERSION = '0.0.1'
-end
-
-require File.dirname(__FILE__) + '/../lib/test_xml/matchers'
-require File.dirname(__FILE__) + '/../lib/test_xml/nokogiri/node'
-require File.dirname(__FILE__) + '/../lib/test_xml/nokogiri'
+require 'test_xml/matchers'
+require 'test_xml/nokogiri/node'
+require 'test_xml/nokogiri'

data/lib/test_xml/spec.rb

@@ -1,42 +1,5 @@
-module TestXml
-  module Spec
-    class MatchXml
-      include TestXml::Matchers
+require 'test_xml/spec/matchers.rb'
 
-      def initialize(expected, compare_values = false)
-        @expected = expected
-        @compare_values = compare_values
-      end
-
-      def matches?(actual)
-        @actual = actual
-        match_xml?(@actual, @expected, @compare_values)
-      end
-
-      def failure_message_for_should
-        "expected\n#{@actual} to match#{structure_message}\n#{@expected}"
-      end
-
-      def failure_message_for_should_not
-        "expected\n#{@actual} not to match#{structure_message}\n#{@expected}"
-      end
-
-      private
-      def structure_message
-        " structure" unless @compare_values
-      end
-    end
-
-    def match_xml(expected)
-      MatchXml.new(expected, true)
-    end
-
-    def match_xml_structure(expected)
-      MatchXml.new(expected, false)
-    end
-  end
-end
-
-class Spec::Example::ExampleGroup
-  include TestXml::Spec
-end
+# class Spec::Example::ExampleGroup
+#   include TestXml::Spec
+# end

data/lib/test_xml/spec/matchers.rb

@@ -0,0 +1,4 @@
+require 'test_xml/spec/matchers/match_xml'
+require 'test_xml/spec/matchers/match_xml_structure'
+require 'test_xml/spec/matchers/exactly_match_xml_structure'
+require 'test_xml/spec/matchers/exactly_match_xml'

data/lib/test_xml/spec/matchers/exactly_match_xml.rb

@@ -0,0 +1,18 @@
+Spec::Matchers.define :exactly_match_xml do |expected|
+  match do |actual|
+    subject = Nokogiri::XML::Document.parse(actual)
+    pattern = Nokogiri::XML::Document.parse(expected)
+
+    compare_values = true
+
+    subject.match?(pattern, compare_values) && pattern.match?(subject, compare_values)
+  end
+
+  failure_message_for_should do |actual|
+    "the xml:\n#{actual}\nshould exactly match xml:\n#{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "the xml:\n#{actual}\nshould not exactly match xml:\n#{expected}\nbut it does"
+  end
+end

data/lib/test_xml/spec/matchers/exactly_match_xml_structure.rb

@@ -0,0 +1,15 @@
+Spec::Matchers.define :exactly_match_xml_structure do |expected|
+  match do |actual|
+    subject = Nokogiri::XML::Document.parse(actual)
+    pattern = Nokogiri::XML::Document.parse(expected)
+    subject.match?(pattern) && pattern.match?(subject)
+  end
+
+  failure_message_for_should do |actual|
+    "the xml:\n#{actual}\nshould exactly match xml structure:\n#{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "the xml:\n#{actual}\nshould not exactly match xml structure:\n#{expected}\nbut it does"
+  end
+end

data/lib/test_xml/spec/matchers/match_xml.rb

@@ -0,0 +1,18 @@
+Spec::Matchers.define :match_xml do |expected|
+  match do |actual|
+    subject = Nokogiri::XML::Document.parse(actual)
+    pattern = Nokogiri::XML::Document.parse(expected)
+
+    compare_values = true
+
+    subject.match?(pattern, compare_values)
+  end
+
+  failure_message_for_should do |actual|
+    "the xml:\n#{actual}\nshould match xml:\n#{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "the xml:\n#{actual}\nshould not match xml:\n#{expected}\nbut it does"
+  end
+end

data/lib/test_xml/spec/matchers/match_xml_structure.rb

@@ -0,0 +1,16 @@
+Spec::Matchers.define :match_xml_structure do |expected|
+  match do |actual|
+    subject = Nokogiri::XML::Document.parse(actual)
+    pattern = Nokogiri::XML::Document.parse(expected)
+
+    subject.match?(pattern)
+  end
+
+  failure_message_for_should do |actual|
+    "the xml:\n#{actual}\nshould match xml structure:\n#{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "the xml:\n#{actual}\nshould not match xml structure:\n#{expected}\nbut it does"
+  end
+end

data/lib/test_xml/test_unit.rb

@@ -1,48 +1,5 @@
-module TestXml
-  module TestUnit
-    include TestXml::Matchers
-
-    def assert_match_xml(xml, message = "")
-      pattern = yield
-      full_message = build_message(message, <<-EOT, xml, pattern)
-        The following xml:
-        ?
-        does not match with:
-        ?
-      EOT
-      assert_block(full_message) do
-        match_xml?(xml, yield, true)
-      end
-    end
-
-    def assert_match_xml_structure(xml, message = "")
-      pattern = yield
-      full_message = build_message(message, <<-EOT, xml, pattern)
-        The following xml:
-        ?
-        does not match with structure of:
-        ?
-      EOT
-      assert_block(full_message) do
-        match_xml?(xml, yield)
-      end
-    end
-
-    def assert_not_match_xml(xml, message = "")
-      pattern = yield
-      full_message = build_message(message, <<-EOT, xml, pattern)
-        The following xml:
-        ?
-        matches with:
-        ?
-      EOT
-      assert_block(full_message) do
-        !match_xml?(xml, yield, true)
-      end
-    end
-  end
-end
+require 'test_xml/test_unit/assertions'
 
 class Test::Unit::TestCase
-  include TestXml::TestUnit
+  include TestXml::TestUnit::Assertions
 end

data/lib/test_xml/test_unit/assertions.rb

@@ -0,0 +1,53 @@
+module TestXml
+  module TestUnit
+    module Assertions
+      def self.assertions_for(name, options)
+        define_method("assert_#{name}") do |subject, &block|
+          pattern = block.call
+
+          actual = Nokogiri::XML.parse(subject)
+          expected = Nokogiri::XML.parse(pattern)
+
+          full_message = options[:message_for_should].gsub(/\<pattern\>/, pattern).gsub(/\<subject\>/, subject)
+
+          assert_block(full_message) do
+            options[:matcher].call(actual, expected)
+          end
+        end
+
+        define_method("assert_not_#{name}") do |subject, &block|
+          pattern = block.call
+
+          actual = Nokogiri::XML.parse(subject)
+          expected = Nokogiri::XML.parse(pattern)
+
+          full_message = options[:message_for_should_not].gsub(/\<pattern\>/, pattern).gsub(/\<subject\>/, subject)
+
+          assert_block(full_message) do
+            !options[:matcher].call(actual, expected)
+          end
+        end
+      end
+
+      assertions_for :match_xml,
+                     :message_for_should     => "the xml:\n<subject>\nshould match xml:\n<pattern>",
+                     :message_for_should_not => "the xml:\n<subject>\nshould not match xml:\n<pattern> but it does",
+                     :matcher => Proc.new {|actual, expected| actual.match?(expected, true)}
+
+      assertions_for :exactly_match_xml,
+                     :message_for_should     => "the xml:\n<subject>\nshould exactly match xml:\n<pattern>",
+                     :message_for_should_not => "the xml:\n<subject>\nshould not exactly match xml:\n<pattern> but it does",
+                     :matcher => Proc.new {|actual, expected| actual.match?(expected, true) && expected.match?(actual, true) }
+
+      assertions_for :match_xml_structure,
+                     :message_for_should     => "the xml:\n<subject>\nshould match xml structure:\n<pattern>",
+                     :message_for_should_not => "the xml:\n<subject>\nshould not match xml structure:\n<pattern> but it does",
+                     :matcher => Proc.new {|actual, expected| actual.match?(expected)}
+
+      assertions_for :exactly_match_xml_structure,
+                     :message_for_should     => "the xml:\n<subject>\nshould exactly match xml structure:\n<pattern>",
+                     :message_for_should_not => "the xml:\n<subject>\nshould not exactly match xml structure:\n<pattern> but it does",
+                     :matcher => Proc.new {|actual, expected| actual.match?(expected) && expected.match?(actual) }
+    end
+  end
+end

data/lib/test_xml/version.rb

@@ -0,0 +1,3 @@
+module TestXml
+  VERSION = '0.0.2'
+end

data/spec/lib/test_xml/spec/matchers/exactly_match_xml_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "exactly_match_xml(xml)" do
+  subject {
+    <<-XML
+      <xml>
+        <one>1</one>
+        <two>2</two>
+      </xml>
+    XML
+  }
+
+  context "when xml is equal with subject" do
+    it "should pass" do
+      should exactly_match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml structure is equal with subject but elements have different content" do
+    it "should fail" do
+      should_not exactly_match_xml(<<-XML)
+        <xml>
+          <one>4</one>
+          <two>5</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has less elements" do
+    it "should fail" do
+      should_not exactly_match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has more elements" do
+    it "should fail" do
+      should_not exactly_match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+          <three>3</three>
+        </xml>
+      XML
+    end
+  end
+end

data/spec/lib/test_xml/spec/matchers/exactly_match_xml_structure_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "exactly_match_xml_structure(xml)" do
+  subject {
+    <<-XML
+      <xml>
+        <one>1</one>
+        <two>2</two>
+      </xml>
+    XML
+  }
+
+  context "when xml structure is equal with subject" do
+    it "should pass" do
+      should exactly_match_xml_structure(<<-XML)
+        <xml>
+          <one/>
+          <two/>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml structure is equal with subject and elements have different content" do
+    it "should pass" do
+      should exactly_match_xml_structure(<<-XML)
+        <xml>
+          <one>4</one>
+          <two>5</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has less elements" do
+    it "should fail" do
+      should_not exactly_match_xml_structure(<<-XML)
+        <xml>
+          <one/>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has more elements" do
+    it "should fail" do
+      should_not exactly_match_xml_structure(<<-XML)
+        <xml>
+          <one/>
+          <two/>
+          <three/>
+        </xml>
+      XML
+    end
+  end
+end

data/spec/lib/test_xml/spec/matchers/match_xml_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "match_xml(xml)" do
+  subject {
+    <<-XML
+      <xml>
+        <one>1</one>
+        <two>2</two>
+      </xml>
+    XML
+  }
+
+  context "when xml is equal" do
+    it "should pass" do
+      should match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has less elements" do
+    it "should pass" do
+      should match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml structure is equal but elements have different content" do
+    it "should fail" do
+      should_not match_xml(<<-XML)
+        <xml>
+          <one>4</one>
+          <two>5</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has more elements" do
+    it "should fail" do
+      should_not match_xml(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+          <three>3</three>
+        </xml>
+      XML
+    end
+  end
+end

data/spec/lib/test_xml/spec/matchers/match_xml_structure_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "match_xml_structure(xml)" do
+  subject {
+    <<-XML
+      <xml>
+        <one>1</one>
+        <two>2</two>
+      </xml>
+    XML
+  }
+
+  context "when xml is equal" do
+    it "should pass" do
+      should match_xml_structure(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml structure is equal but elements have different content" do
+    it "should pass" do
+      should match_xml_structure(<<-XML)
+        <xml>
+          <one>4</one>
+          <two>5</two>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has less elements" do
+    it "should pass" do
+      should match_xml_structure(<<-XML)
+        <xml>
+          <one>1</one>
+        </xml>
+      XML
+    end
+  end
+
+  context "when xml has more elements" do
+    it "should fail" do
+      should_not match_xml_structure(<<-XML)
+        <xml>
+          <one>1</one>
+          <two>2</two>
+          <three>3</three>
+        </xml>
+      XML
+    end
+  end
+end

data/test/test_xml/test_unit/test_assertions.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class TestAssertions < Test::Unit::TestCase
+  def test_assert_match_xml
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>2</two>
+      </root>
+    XML
+
+    assert_match_xml(xml) do
+      <<-XML
+        <root>
+          <one>1</one>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_not_match_xml
+    xml = <<-XML
+      <root>
+        <one>1</one>
+      </root>
+    XML
+
+    assert_not_match_xml(xml) do
+      <<-XML
+        <root>
+          <one>2</one>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_match_xml_structure
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>
+          <three>3</three>
+        </two>
+      </root>
+    XML
+
+    assert_match_xml_structure(xml) do
+      <<-XML
+        <root>
+          <one>2</one>
+          <two>
+            <three>4</three>
+          </two>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_not_match_xml_structure
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>
+          <three>3</three>
+        </two>
+      </root>
+    XML
+
+    assert_not_match_xml_structure(xml) do
+      <<-XML
+        <root>
+          <one>2</one>
+          <two>
+            <four/>
+          </two>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_exactly_match_xml
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>2</two>
+      </root>
+    XML
+
+    assert_exactly_match_xml(xml) do
+      <<-XML
+        <root>
+          <one>1</one>
+          <two>2</two>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_not_exactly_match_xml
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>2</two>
+      </root>
+    XML
+
+    assert_not_exactly_match_xml(xml) do
+      <<-XML
+        <root>
+          <one>1</one>
+        </root>
+      XML
+    end
+  end
+  def test_assert_exactly_match_xml_structure
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>
+          <three>3</three>
+        </two>
+      </root>
+    XML
+
+    assert_exactly_match_xml_structure(xml) do
+      <<-XML
+        <root>
+          <one>2</one>
+          <two>
+            <three>4</three>
+          </two>
+        </root>
+      XML
+    end
+  end
+
+  def test_assert_not_exactly_match_xml_structure
+    xml = <<-XML
+      <root>
+        <one>1</one>
+        <two>
+          <three>3</three>
+        </two>
+      </root>
+    XML
+
+    assert_not_match_xml_structure(xml) do
+      <<-XML
+        <root>
+          <one>2</one>
+          <two>
+            <three>3</three>
+            <four/>
+          </two>
+        </root>
+      XML
+    end
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: test_xml
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Pavel Gabriel
@@ -9,68 +14,84 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-04 00:00:00 +02:00
+date: 2010-06-07 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: nokogiri
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 2
         version: 1.3.2
-    version: 
-description: test_xml allows you to test xml (match stucture and values) with Test::Unit or RSpec
+  type: :runtime
+  version_requirements: *id001
+description: test_xml allows you to test xml (match stucture and values) with RSpec, Test::Unit, Cucumber
 email: alovak@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
 files: 
-- lib/test_xml/matchers.rb
 - lib/test_xml/nokogiri/node.rb
 - lib/test_xml/nokogiri.rb
+- lib/test_xml/spec/matchers/exactly_match_xml.rb
+- lib/test_xml/spec/matchers/exactly_match_xml_structure.rb
+- lib/test_xml/spec/matchers/match_xml.rb
+- lib/test_xml/spec/matchers/match_xml_structure.rb
+- lib/test_xml/spec/matchers.rb
 - lib/test_xml/spec.rb
+- lib/test_xml/test_unit/assertions.rb
 - lib/test_xml/test_unit.rb
+- lib/test_xml/version.rb
 - lib/test_xml.rb
 - test/test_helper.rb
 - test/test_xml/nokogiri/test_node.rb
-- test/test_xml/test_matchers.rb
-- test/test_xml/test_test_unit.rb
+- test/test_xml/test_unit/test_assertions.rb
+- spec/lib/test_xml/spec/matchers/exactly_match_xml_spec.rb
+- spec/lib/test_xml/spec/matchers/exactly_match_xml_structure_spec.rb
+- spec/lib/test_xml/spec/matchers/match_xml_spec.rb
+- spec/lib/test_xml/spec/matchers/match_xml_structure_spec.rb
 - spec/spec_helper.rb
-- spec/test_xml/spec_spec.rb
 - Rakefile
+- README.rdoc
 has_rdoc: true
-homepage: http://github.com/alovak/
+homepage: http://github.com/alovak/test_xml
 licenses: []
 
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --main
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: test_xml allows you to test xml with Test::Unit or RSpec
+summary: test_xml allows you to test xml with RSpec, Test::Unit, Cucumber
 test_files: []
 

data/lib/test_xml/matchers.rb

@@ -1,21 +0,0 @@
-module TestXml
-  module Matchers
-    class XmlMatcher
-      attr_reader :subject, :pattern, :compare_value
-      def initialize(subject, pattern, compare_value)
-        @subject = Nokogiri::XML::Document.parse(subject)
-        @pattern = Nokogiri::XML::Document.parse(pattern)
-        @compare_value = compare_value
-      end
-
-      def match?
-        subject.match?(pattern, compare_value)
-      end
-    end
-
-    def match_xml?(subject, pattern, compare_value = false)
-      matcher = XmlMatcher.new(subject, pattern, compare_value)
-      matcher.match?
-    end
-  end
-end

data/spec/test_xml/spec_spec.rb

@@ -1,47 +0,0 @@
-require 'spec/spec_helper'
-
-describe "xml" do
-  before(:each) do
-    @xml = <<-XML
-      <root>
-        <one>1</one>
-        <two>2</two>
-      </root>
-    XML
-  end
-
-  it "should match_xml" do
-    @xml.should match_xml(<<-XML)
-      <root>
-        <one>1</one>
-        <two>2</two>
-      </root>
-    XML
-  end
-
-  it "should not match_xml" do
-    @xml.should_not match_xml(<<-XML)
-      <root>
-        <one>2</one>
-      </root>
-    XML
-  end
-
-  it "should match_xml_structure" do
-    @xml.should match_xml_structure(<<-XML)
-      <root>
-        <one>2</one>
-        <two>1</two>
-      </root>
-    XML
-  end
-
-  it "should not match_xml_structure" do
-    @xml.should_not match_xml_structure(<<-XML)
-      <root>
-        <one>2</one>
-        <three>1</three>
-      </root>
-    XML
-  end
-end

data/test/test_xml/test_matchers.rb

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-class TestMatchers < Test::Unit::TestCase
-  include TestXml::Matchers
-
-  def test_match
-    actual = <<-XML
-      <root>
-        <one>
-          <two>2</two>
-        </one>
-      </root>
-    XML
-
-    assert  match_xml?(actual, '<root><one><two/></one></root>')
-    assert !match_xml?(actual, '<root><two/></root>')
-  end
-
-  def test_match_with_values
-    actual = <<-XML
-      <root>
-        <one>1</one>
-        <two>2</two>
-      </root>
-    XML
-
-    assert  match_xml?(actual, '<root><one>1</one></root>', true)
-    assert !match_xml?(actual, '<root><one>2</one></root>', true)
-  end
-end

data/test/test_xml/test_test_unit.rb

@@ -1,55 +0,0 @@
-require 'test_helper'
-
-class TestTestUnit < Test::Unit::TestCase
-  def test_assert_match_xml
-    xml = <<-XML
-      <root>
-        <one>1</one>
-      </root>
-    XML
-
-    assert_match_xml(xml) do
-      <<-XML
-        <root>
-          <one>1</one>
-        </root>
-      XML
-    end
-  end
-
-  def test_assert_match_xml_structure
-    xml = <<-XML
-      <root>
-        <one>1</one>
-        <two>
-          <three>3</three>
-        </two>
-      </root>
-    XML
-
-    assert_match_xml_structure(xml) do
-      <<-XML
-        <root>
-          <one>2</one>
-          <two><three/></two>
-        </root>
-      XML
-    end
-  end
-
-  def test_assert_not_match_xml
-    xml = <<-XML
-      <root>
-        <one>1</one>
-      </root>
-    XML
-
-    assert_not_match_xml(xml) do
-      <<-XML
-        <root>
-          <one>2</one>
-        </root>
-      XML
-    end
-  end
-end