test_xml 0.0.4 → 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+*.swp

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gemspec
+
+group :test do
+  gem 'rspec', ">= 2.2"
+  gem 'rdoc'
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    test_xml (0.0.4)
+      nokogiri (>= 1.3.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    nokogiri (1.4.4)
+    rake (0.8.7)
+    rdoc (3.5.3)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rdoc
+  rspec (>= 2.2)
+  rspec-core (~> 2.2)
+  test_xml!

data/README.rdoc

@@ -1,24 +1,46 @@
 = 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.
+TestXml is a small extension for testing XML/HTML. Extending RSpec and TestUnit it makes asserting and comparing XML snippets easy, and is especially helpful for testing RESTful web services and their XML representations.
+
 
 == FEATURES:
 
-* test XML with: RSpec, Test::Unit, Cucumber
-* test XML structure (partially or fully matched)
-* test the element values within XML structure
+* runs with RSpec2, Test::Unit, MiniTest and Cucumber
+* Ruby 1.8 and 1.9
+* test XML structure and content
+
+
+== INSTALL
+
+  gem install test_xml
+
 
 == EXAMPLES:
 
-=== Cucumber feature
+=== Test::Unit and MiniTest
+
+  def test_item_representation
+    assert_xml_equal "<item><id>1</id></item>", @item.to_xml
+  end
+
+=== RSpec
+
+  it "should contain the id" do
+    @item.to_xml.should equal_xml(<<-XML)
+      <item>
+        <id>1</id>
+      </item>
+    XML
+  end
+
+=== Cucumber
 
   Scenario:
-    Given data
-    When I post the data
-    The I receive successful response
-    And response matches the following xml
+    When I post some data
+    Then the response should match the following xml
     """
       <transaction>
         <status>success</status>
@@ -27,97 +49,58 @@ TestXml is a small extension for RSpec and TestUnit for XML/HTML testing. I have
       </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
+In your 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
+And in the actual spec, use these matchers:
 
-* match_xml
-* exactly_match_xml
-* match_xml_structure
-* exactly_match_xml_structure
+* equal_xml
+* contain_xml
+* equal_xml_structure
+* contain_xml_structure
 
-=== With Test::Unit
+=== Test::Unit
 
-in test_helper.rb
+In the test_helper.rb
 
-  require 'test_xml'
   require 'test_xml/test_unit'
 
-in test file:
+In your test file, use these matchers:
 
-  def test_that_xml_matches
-    xml = <<-XML
-      <root>
-        <one>1</one>
-      </root>
-    XML
+* assert_xml_equal
+* assert_xml_contain
+* assert_xml_structure_equal
+* assert_xml_structure_contain
 
-    assert_match_xml(xml) do
-      <<-XML
-        <root>
-          <one>1</one>
-        </root>
-      XML
-    end
-  end
+Negative assertions are available as <tt>assert_not_*</tt>.
+
+=== MiniTest
 
-=== Implemented assertions
+In the test_helper.rb
 
-* assert_match_xml
-* assert_exactly_match_xml
-* assert_match_xml_structure
-* assert_exactly_match_xml_structure
+  require 'test_xml/mini_test'
 
-with assert_not_*
+Check the Test::Unit section for available assertions.
 
-=== With Cucumber
+=== Cucumber
 
-Add to features/env.rb
+In the 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|
+In your steps file e.g. features/step_definitions/xml_steps.rb add this step:
+  
+  Then /^the response should match the following xml$/ do |string|
     response.body.should match_xml(string)
   end
 
 == REQUIREMENTS
 
-test_xml depends on Nokogiri
-
-== INSTALL
-
-  [sudo] gem install test_xml
+* nokogiri

data/Rakefile

@@ -1,22 +1,22 @@
-require 'rubygems'
-require 'rake'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+Bundler.setup
+
 require 'rake/testtask'
-require 'spec/rake/spectask'
+require 'rspec/core/rake_task'
 require 'rdoc/task'
 
-task :default => ['test:units', :spec]
+task :default => ['test', :spec]
 
-namespace :test do
-  Rake::TestTask.new(:units) do |t|
-    t.test_files = FileList['test/**/test_*.rb']
-    t.libs << "test"
-    t.verbose = true
-  end
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/test_*.rb']
+  t.libs << "test"
+  t.verbose = true
 end
 
 
-Spec::Rake::SpecTask.new do |t|
-    t.libs << "spec"
+RSpec::Core::RakeTask.new do |t|
+    #t.libs << "spec"
     t.verbose = true
 end
 

data/lib/test_xml.rb

@@ -1,5 +1,3 @@
-require 'rubygems'
 require 'nokogiri'
-
 require 'test_xml/nokogiri/node'
 require 'test_xml/nokogiri'

data/lib/test_xml/matcher_methods.rb

@@ -0,0 +1,29 @@
+module TestXml
+  # This module implements the actual matchers with their conditions.
+  module MatcherMethods
+    def self.xml_contain(subject, pattern)
+      actual, expected = parse_xml(subject, pattern)
+      actual.match?(expected, true)
+    end
+    
+    def self.xml_equal(subject, pattern)
+      actual, expected = parse_xml(subject, pattern)
+      actual.match?(expected, true) && expected.match?(actual, true)
+    end
+    
+    def self.xml_structure_contain(subject, pattern)
+      actual, expected = parse_xml(subject, pattern)
+      actual.match?(expected)
+    end
+    
+    def self.xml_structure_equal(subject, pattern)
+      actual, expected = parse_xml(subject, pattern)
+      actual.match?(expected) && expected.match?(actual)
+    end
+    
+  private
+    def self.parse_xml(subject, pattern)
+      [Nokogiri::XML.parse(subject), Nokogiri::XML.parse(pattern)]
+    end
+  end
+end

data/lib/test_xml/mini_test.rb

@@ -0,0 +1,6 @@
+require "test_xml"
+require 'test_xml/test_unit/assertions'
+
+class MiniTest::Unit::TestCase
+  include TestXml::TestUnit::Assertions
+end

data/lib/test_xml/nokogiri/node.rb

@@ -2,23 +2,29 @@ module TestXml
   module NokogiriExt
     module Node
       def match?(element, compare_value = false)
-        if compare_value && element.text_element?
-          equal_text?(element)
+        if compare_value && element.leaf?
+          comparable_attributes == element.comparable_attributes and equal_text?(element)
         else
           contains_elements_of?(element) &&
           element.elements.all? {|el| matches_at_least_one?(el, compare_value) }
         end
       end
-
+      
       def elements
         children.collect {|node| node if node.element? }.delete_if {|node| node.nil?}
       end
-
-      def text_element?
-        children.size == 1 && children.first.text?
+      
+      # Attributes of the current node.
+      def comparable_attributes
+        attributes.collect {|k,a| [k.downcase, a.value]}.sort
+      end
+      
+      # Check if node is either childless, self-closing, or has content text. 
+      def leaf?
+        children.size == 0 or (children.size == 1 && children.first.text?)
       end
 
-      private
+    private
       def equal_text?(element)
         content == element.content
       end
@@ -34,7 +40,6 @@ module TestXml
       def matches_at_least_one?(element, compare_value)
         search(element.name).find { |el| el.match?(element, compare_value) }
       end
-
     end
   end
 end

data/lib/test_xml/spec.rb

@@ -1,5 +1,2 @@
+require 'test_xml'
 require 'test_xml/spec/matchers.rb'
-
-# class Spec::Example::ExampleGroup
-#   include TestXml::Spec
-# end

data/lib/test_xml/spec/matchers.rb

@@ -1,4 +1,5 @@
-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'
+require 'test_xml/matcher_methods'
+require 'test_xml/spec/matchers/contain_xml'
+require 'test_xml/spec/matchers/contain_xml_structure'
+require 'test_xml/spec/matchers/equal_xml_structure'
+require 'test_xml/spec/matchers/equal_xml'

data/lib/test_xml/spec/matchers/{match_xml.rb → contain_xml.rb}

@@ -1,11 +1,6 @@
-Spec::Matchers.define :match_xml do |expected|
+RSpec::Matchers.define :contain_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)
+    TestXml::MatcherMethods.xml_contain(actual, expected)
   end
 
   failure_message_for_should do |actual|

data/lib/test_xml/spec/matchers/{match_xml_structure.rb → contain_xml_structure.rb}

@@ -1,9 +1,6 @@
-Spec::Matchers.define :match_xml_structure do |expected|
+RSpec::Matchers.define :contain_xml_structure do |expected|
   match do |actual|
-    subject = Nokogiri::XML::Document.parse(actual)
-    pattern = Nokogiri::XML::Document.parse(expected)
-
-    subject.match?(pattern)
+    TestXml::MatcherMethods.xml_structure_contain(actual, expected)
   end
 
   failure_message_for_should do |actual|

data/lib/test_xml/spec/matchers/{exactly_match_xml.rb → equal_xml.rb}

@@ -1,11 +1,6 @@
-Spec::Matchers.define :exactly_match_xml do |expected|
+RSpec::Matchers.define :equal_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)
+    TestXml::MatcherMethods.xml_equal(actual, expected)
   end
 
   failure_message_for_should do |actual|

data/lib/test_xml/spec/matchers/{exactly_match_xml_structure.rb → equal_xml_structure.rb}

@@ -1,8 +1,6 @@
-Spec::Matchers.define :exactly_match_xml_structure do |expected|
+RSpec::Matchers.define :equal_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)
+    TestXml::MatcherMethods.xml_structure_equal(actual, expected)
   end
 
   failure_message_for_should do |actual|

data/lib/test_xml/test_unit.rb

@@ -1,3 +1,5 @@
+require "test/unit"
+require "test_xml"
 require 'test_xml/test_unit/assertions'
 
 class Test::Unit::TestCase

data/lib/test_xml/test_unit/assertions.rb

@@ -1,53 +1,50 @@
+require 'test_xml/matcher_methods'
+
 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)
 
+      def self.assertions_for(name, options)
+        define_method("assert_#{name}") do |subject, pattern|
           full_message = options[:message_for_should].gsub(/\<pattern\>/, pattern).gsub(/\<subject\>/, subject)
 
-          assert_block(full_message) do
-            options[:matcher].call(actual, expected)
-          end
+          correct_assert(MatcherMethods.send(name, subject, pattern), full_message)
         end
 
-        define_method("assert_not_#{name}") do |subject, &block|
-          pattern = block.call
-
-          actual = Nokogiri::XML.parse(subject)
-          expected = Nokogiri::XML.parse(pattern)
-
+        define_method("assert_not_#{name}") do |subject, 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
+          correct_assert(!MatcherMethods.send(name, subject, pattern), full_message)
         end
       end
+      
+      
+      assertions_for :xml_contain,
+                     :message_for_should     => "the xml:\n<subject>\nshould contain xml:\n<pattern>",
+                     :message_for_should_not => "the xml:\n<subject>\nshould not contain xml:\n<pattern> but it does"
 
-      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,
+      assertions_for :xml_equal,
                      :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) }
+                     :message_for_should_not => "the xml:\n<subject>\nshould not exactly match xml:\n<pattern> but it does"
 
-      assertions_for :match_xml_structure,
+      assertions_for :xml_structure_contain,
                      :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)}
+                     :message_for_should_not => "the xml:\n<subject>\nshould not match xml structure:\n<pattern> but it does"
 
-      assertions_for :exactly_match_xml_structure,
+      assertions_for :xml_structure_equal,
                      :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) }
+                     :message_for_should_not => "the xml:\n<subject>\nshould not exactly match xml structure:\n<pattern> but it does"
+
+      private
+      def correct_assert(boolean, message)
+        if RUBY_VERSION =~ /1.9.2/ or defined?(MiniTest)
+          assert(boolean, message)
+        else
+          assert_block(message) do
+            boolean
+          end
+        end
+      end
     end
   end
 end