From 806cf6d76ab557ceebf5ac5d22f3e39076e1ab61 Mon Sep 17 00:00:00 2001
From: David Heinemeier Hansson <david@loudthinking.com>
Date: Sun, 17 Apr 2005 16:43:48 +0000
Subject: Added assert_tag and assert_no_tag as a much improved alternative to
 the deprecated assert_template_xpath_match #1126 [Jamis Buck]

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@1195 5ecf4fe2-1ee6-0310-87b1-e25e094e27de
---
 actionpack/lib/action_controller/assertions.rb | 84 +++++++++++++++++++++++++-
 1 file changed, 83 insertions(+), 1 deletion(-)

(limited to 'actionpack/lib/action_controller/assertions.rb')

diff --git a/actionpack/lib/action_controller/assertions.rb b/actionpack/lib/action_controller/assertions.rb
index 38d551bca2..0c1ca76e19 100644
--- a/actionpack/lib/action_controller/assertions.rb
+++ b/actionpack/lib/action_controller/assertions.rb
@@ -116,6 +116,88 @@ module Test #:nodoc:
         assert_recognizes(options, path, extras, message)
         assert_generates(path, options, defaults, extras, message)
       end
+
+      # Asserts that there is a tag/node/element in the body of the response
+      # that meets all of the given conditions. The +conditions+ parameter must
+      # be a hash of any of the following keys (all are optional):
+      #
+      # * <tt>:tag</tt>: the node type must match the corresponding value
+      # * <tt>:attributes</tt>: a hash. The node's attributes must match the
+      #   corresponding values in the hash.
+      # * <tt>:parent</tt>: a hash. The node's parent must match the
+      #   corresponding hash.
+      # * <tt>:child</tt>: a hash. At least one of the node's immediate children
+      #   must meet the criteria described by the hash.
+      # * <tt>:ancestor</tt>: a hash. At least one of the node's ancestors must
+      #   meet the criteria described by the hash.
+      # * <tt>:descendant</tt>: a hash. At least one of the node's descendants
+      #   must meet the criteria described by the hash.
+      # * <tt>:children</tt>: a hash, for counting children of a node. Accepts
+      #   the keys:
+      # ** <tt>:count</tt>: either a number or a range which must equal (or
+      #    include) the number of children that match.
+      # ** <tt>:less_than</tt>: the number of matching children must be less
+      #    than this number.
+      # ** <tt>:greater_than</tt>: the number of matching children must be
+      #    greater than this number.
+      # ** <tt>:only</tt>: another hash consisting of the keys to use
+      #    to match on the children, and only matching children will be
+      #    counted.
+      # * <tt>:content</tt>: (text nodes only). The content of the node must
+      #   match the given value.
+      #
+      # Conditions are matched using the following algorithm:
+      #
+      # * if the condition is a string, it must be a substring of the value.
+      # * if the condition is a regexp, it must match the value.
+      # * if the condition is a number, the value must match number.to_s.
+      # * if the condition is +true+, the value must not be +nil+.
+      # * if the condition is +false+ or +nil+, the value must be +nil+.
+      #
+      # Usage:
+      #
+      #   # assert that there is a "span" tag
+      #   assert_tag :tag => "span"
+      #
+      #   # assert that there is a "span" inside of a "div"
+      #   assert_tag :tag => "span", :parent => { :tag => "div" }
+      #
+      #   # assert that there is a "span" somewhere inside a table
+      #   assert_tag :tag => "span", :ancestor => { :tag => "table" }
+      #
+      #   # assert that there is a "span" with at least one "em" child
+      #   assert_tag :tag => "span", :child => { :tag => "em" }
+      #
+      #   # assert that there is a "span" containing a (possibly nested)
+      #   # "strong" tag.
+      #   assert_tag :tag => "span", :descendant => { :tag => "strong" }
+      #
+      #   # assert that there is a "span" containing between 2 and 4 "em" tags
+      #   # as immediate children
+      #   assert_tag :tag => "span",
+      #              :children => { :count => 2..4, :only => { :tag => "em" } } 
+      #
+      #   # get funky: assert that there is a "div", with an "ul" ancestor
+      #   # and an "li" parent (with "class" = "enum"), and containing a 
+      #   # "span" descendant that contains text matching /hello world/
+      #   assert_tag :tag => "div",
+      #              :ancestor => { :tag => "ul" },
+      #              :parent => { :tag => "li",
+      #                           :attributes => { :class => "enum" } },
+      #              :descendant => { :tag => "span",
+      #                               :child => /hello world/ }
+      def assert_tag(opts)
+        tag = find_tag(opts)
+        assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
+      end
+      
+      # Identical to #assert_tag, but asserts that a matching tag does _not_
+      # exist. (See #assert_tag for a full discussion of the syntax.)
+      def assert_no_tag(opts)
+        tag = find_tag(opts)
+        assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
+      end
+    
     end
   end
-end
\ No newline at end of file
+end
-- 
cgit v1.2.3