Merge branch 'master' into atmos

History.txt

@@ -1,11 +1,24 @@
-== Git
+== 0.4.2 / 2009-02-24
 
+* Major enhancements
+
+  * Significant improvements to have_selector. It now supports specifying
+    attributes in a hash and :count and :content options. See
+    have_selector_spec.rb for more.
+  * Add the same functionality mentioned above to have_xpath
+    
 * Minor enhancements
 
-  * Detect infinite redirects and raise a Webrat::InfiniteRedirectError (Daniel Lucraft)
+  * Squeeze extra whitespace out of failures messages from contain
+    matcher
+  * Detect infinite redirects and raise a Webrat::InfiniteRedirectError
+    (Daniel Lucraft)
 
 * Bug fixes
 
+  * Properly quote single and double quotes strings in XPath
+  * Fix warning caused by Nokogiri deprecating CSS::Parser.parse
+    (Aaron Patterson)
   * Accept do/end blocks in matchers. [#157] (Peter Jaros)
   * Quote --chdir option to mongrel_rails to support RAILS_ROOTs with spaces
     (T.J. VanSlyke)

Rakefile

@@ -28,7 +28,7 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = %w(README.rdoc MIT-LICENSE.txt)
 
   # Dependencies
-  s.add_dependency "nokogiri", ">= 1.1.0"
+  s.add_dependency "nokogiri", ">= 1.2.0"
 
   s.rubyforge_project = "webrat"
 end

lib/webrat.rb

@@ -7,7 +7,7 @@ module Webrat
   class WebratError < StandardError
   end
 
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 
   def self.require_xml
     gem "nokogiri", ">= 1.0.6"

lib/webrat/core/matchers/have_content.rb

@@ -26,15 +26,19 @@ module Webrat
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected the following element's content to #{content_message}:\n#{@element}"
+        "expected the following element's content to #{content_message}:\n#{squeeze_space(@element)}"
       end
 
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected the following element's content to not #{content_message}:\n#{@element}"
+        "expected the following element's content to not #{content_message}:\n#{squeeze_space(@element)}"
       end
-    
+      
+      def squeeze_space(inner_text)
+        inner_text.gsub(/^\s*$/, "").squeeze("\n")
+      end
+      
       def content_message
         case @content
         when String

lib/webrat/core/matchers/have_selector.rb

@@ -1,24 +1,46 @@
+require "webrat/core/matchers/have_xpath"
+
 module Webrat
   module Matchers
     
     class HaveSelector < HaveXpath #:nodoc:
-
       # ==== Returns
       # String:: The failure message.
       def failure_message
-        "expected following text to match selector #{@expected}:\n#{@document}"
+        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
       end
-    
+
       # ==== Returns
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
-        "expected following text to not match selector #{@expected}:\n#{@document}"
+        "expected following output to omit a #{tag_inspect}:\n#{@document}"
       end
-    
+      
+      def tag_inspect
+        options = @options.dup
+        count = options.delete(:count)
+        content = options.delete(:content)
+
+        html = "<#{@expected}"
+        options.each do |k,v|
+          html << " #{k}='#{v}'"
+        end
+
+        if content
+          html << ">#{content}</#{@expected}>"
+        else
+          html << "/>"
+        end
+
+        html
+      end
+
       def query
-        Nokogiri::CSS::Parser.parse(*super).map { |ast| ast.to_xpath }
+        Nokogiri::CSS.parse(@expected.to_s).map do |ast|
+          ast.to_xpath
+        end.first
       end
-  
+      
     end
     
     # Matches HTML content against a CSS 3 selector.
@@ -28,24 +50,24 @@ module Webrat
     #
     # ==== Returns
     # HaveSelector:: A new have selector matcher.
-    def have_selector(expected, &block)
+    def have_selector(name, attributes = {}, &block)
-      HaveSelector.new(expected, &block)
+      HaveSelector.new(name, attributes, &block)
     end
     alias_method :match_selector, :have_selector
     
     
     # Asserts that the body of the response contains
     # the supplied selector
-    def assert_have_selector(expected)
+    def assert_have_selector(name, attributes = {}, &block)
-      hs = HaveSelector.new(expected)
+      matcher = HaveSelector.new(name, attributes, &block)
-      assert hs.matches?(response_body), hs.failure_message
+      assert matcher.matches?(response_body), matcher.failure_message
     end
     
     # Asserts that the body of the response
     # does not contain the supplied string or regepx
-    def assert_have_no_selector(expected)
+    def assert_have_no_selector(name, attributes = {}, &block)
-      hs = HaveSelector.new(expected)
+      matcher = HaveSelector.new(name, attributes, &block)
-      assert !hs.matches?(response_body), hs.negative_failure_message
+      assert !matcher.matches?(response_body), matcher.negative_failure_message
     end
     
   end

lib/webrat/core/matchers/have_tag.rb

@@ -1,70 +1,20 @@
+require "webrat/core/matchers/have_selector"
+
 module Webrat
-  
   module HaveTagMatcher
 
-    class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
+    def have_tag(*args, &block)
-      # ==== Returns
+      have_selector(*args, &block)
-      # String:: The failure message.
-      def failure_message
-        "expected following output to contain a #{tag_inspect} tag:\n#{@document}"
-      end
-
-      # ==== Returns
-      # String:: The failure message to be displayed in negative matches.
-      def negative_failure_message
-        "expected following output to omit a #{tag_inspect}:\n#{@document}"
-      end
-
-      def tag_inspect
-        options = @expected.last.dup
-        content = options.delete(:content)
-
-        html = "<#{@expected.first}"
-        options.each do |k,v|
-          html << " #{k}='#{v}'"
-        end
-
-        if content
-          html << ">#{content}</#{@expected.first}>"
-        else
-          html << "/>"
-        end
-
-        html
-      end
-
-      def query
-        options  = @expected.last.dup
-        selector = @expected.first.to_s
-
-        selector << ":contains('#{options.delete(:content)}')" if options[:content]
-
-        options.each do |key, value|
-          selector << "[#{key}='#{value}']"
-        end
-
-        Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
-      end
-    end
-
-    def have_tag(name, attributes = {}, &block)
-      HaveTag.new([name, attributes], &block)
     end
     
     alias_method :match_tag, :have_tag
     
-    # Asserts that the body of the response contains
+    def assert_have_tag(*args, &block)
-    # the supplied tag with the associated selectors
+      assert_have_selector(*args, &block)
-    def assert_have_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      assert ht.matches?(response_body), ht.failure_message
     end
     
-    # Asserts that the body of the response
+    def assert_have_no_tag(*args, &block)
-    # does not contain the supplied string or regepx
+      assert_have_no_selector(*args, &block)
-    def assert_have_no_tag(name, attributes = {})
-      ht = HaveTag.new([name, attributes])
-      assert !ht.matches?(response_body), ht.negative_failure_message
     end
 
   end

lib/webrat/core/matchers/have_xpath.rb

@@ -5,55 +5,90 @@ module Webrat
   module Matchers
     
     class HaveXpath #:nodoc:
-      def initialize(expected, &block)
+      def initialize(expected, options = {}, &block)
         @expected = expected
+        @options  = options
         @block    = block
       end
     
       def matches?(stringlike, &block)
         @block ||= block
+        matched = matches(stringlike)
         
-        if Webrat.configuration.parse_with_nokogiri?
+        if @options[:count]
-          matches_nokogiri?(stringlike)
+          matched.size == @options[:count] && (!@block || @block.call(matched))
         else
-          matches_rexml?(stringlike)
+          matched.any? && (!@block || @block.call(matched))
+        end
+      end
+      
+      def matches(stringlike)
+        if Webrat.configuration.parse_with_nokogiri?
+          nokogiri_matches(stringlike)
+        else
+          rexml_matches(stringlike)
         end
       end
     
-      def matches_rexml?(stringlike)
+      def rexml_matches(stringlike)
         if REXML::Node === stringlike || Array === stringlike
           @query = query.map { |q| q.gsub(%r'//', './') }
         else
           @query = query
         end
 
+        add_options_conditions_to(@query)
+
         @document = Webrat.rexml_document(stringlike)
 
-        matched = @query.map do |q|
+        @query.map do |q|
           if @document.is_a?(Array)
             @document.map { |d| REXML::XPath.match(d, q) }
           else
             REXML::XPath.match(@document, q)
           end
         end.flatten.compact
-
-        matched.any? && (!@block || @block.call(matched))
       end
     
-      def matches_nokogiri?(stringlike)
+      def nokogiri_matches(stringlike)
         if Nokogiri::XML::NodeSet === stringlike
-          @query = query.map { |q| q.gsub(%r'//', './') }
+          @query = query.gsub(%r'//', './')
         else
           @query = query
         end
         
+        add_options_conditions_to(@query)
+        
         @document = Webrat::XML.document(stringlike)
-        matched = @document.xpath(*@query)
+        @document.xpath(*@query)
-        matched.any? && (!@block || @block.call(matched))
+      end
+      
+      def add_options_conditions_to(query)
+        add_attributes_conditions_to(query)
+        add_content_condition_to(query)
+      end
+      
+      def add_attributes_conditions_to(query)
+        attribute_conditions = []
+        
+        @options.each do |key, value|
+          next if [:content, :count].include?(key)
+          attribute_conditions << "@#{key} = #{xpath_escape(value)}"
+        end
+        
+        if attribute_conditions.any?
+          query << "[#{attribute_conditions.join(' and ')}]"
+        end
+      end
+      
+      def add_content_condition_to(query)
+        if @options[:content]
+          query << "[contains(., #{xpath_escape(@options[:content])})]"
+        end
       end
       
       def query
-        [@expected].flatten.compact
+        @expected
       end
     
       # ==== Returns
@@ -66,7 +101,24 @@ module Webrat
       # String:: The failure message to be displayed in negative matches.
       def negative_failure_message
         "expected following text to not match xpath #{@expected}:\n#{@document}"
-      end    
+      end
+      
+    protected
+    
+      def xpath_escape(string)
+        if string.include?("'") && string.include?('"')
+          parts = string.split("'").map do |part|
+            "'#{part}'"
+          end
+          
+          "concat(" + parts.join(", \"'\", ") + ")"
+        elsif string.include?("'")
+          "\"#{string}\""
+        else
+          "'#{string}'"
+        end
+      end
+      
     end
     
     # Matches HTML content against an XPath query
@@ -76,18 +128,18 @@ module Webrat
     #
     # ==== Returns
     # HaveXpath:: A new have xpath matcher.
-    def have_xpath(expected, &block)
+    def have_xpath(expected, options = {}, &block)
-      HaveXpath.new(expected, &block)
+      HaveXpath.new(expected, options, &block)
     end
     alias_method :match_xpath, :have_xpath
     
-    def assert_have_xpath(expected, &block)
+    def assert_have_xpath(expected, options = {}, &block)
-      hs = HaveXpath.new(expected, &block)
+      hs = HaveXpath.new(expected, options, &block)
       assert hs.matches?(response_body), hs.failure_message
     end
     
-    def assert_have_no_xpath(expected, &block)
+    def assert_have_no_xpath(expected, options = {}, &block)
-      hs = HaveXpath.new(expected, &block)
+      hs = HaveXpath.new(expected, options, &block)
       assert !hs.matches?(response_body), hs.negative_failure_message
     end
     

lib/webrat/selenium/matchers/have_tag.rb

@@ -43,7 +43,7 @@ module Webrat
             selector << "[#{key}='#{value}']"
           end
   
-          Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
+          Nokogiri::CSS.parse(selector).map { |ast| ast.to_xpath }
         end
       end
   

spec/public/matchers/contain_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "contain" do
+  include Webrat::Matchers
+  
+  before(:each) do
+    @body = <<-HTML
+      <div id='main'>
+        <div class='inner'>hello, world!</div>
+        <h2>Welcome "Bryan"</h2>
+        <h3>Welcome 'Bryan'</h3>
+        <h4>Welcome 'Bryan"</h4>
+        <ul>
+          <li>First</li>
+          <li>Second</li>
+        </ul>
+      </div>
+    HTML
+  end
+
+  before(:each) do
+    @body = <<-EOF
+      <div id='main'>
+        <div class='inner'>hello, world!</div>
+      </div>
+    EOF
+  end
+  
+  describe "#matches?" do
+    it "should call element#contains? when the argument is a string" do
+      @body.should contain("hello, world!")
+    end
+    
+    it "should call element#matches? when the argument is a regular expression" do
+      @body.should contain(/hello, world/)
+    end
+  end
+  
+  describe "asserts for contains," do
+    include Test::Unit::Assertions
+    
+    before(:each) do
+      should_receive(:response_body).and_return @body
+      require 'test/unit'
+    end
+    
+    describe "assert_contain" do
+      it "should pass when containing the text" do
+        assert_contain("hello, world")
+      end
+      
+      it "should pass when containing the regexp" do
+        assert_contain(/hello, world/)
+      end
+      
+      it "should throw an exception when the body doesnt contain the text" do
+        lambda {
+          assert_contain("monkeys")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+      
+      it "should throw an exception when the body doesnt contain the regexp" do
+        lambda {
+          assert_contain(/monkeys/)
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+    
+    describe "assert_not_contain" do
+      it "should pass when not containing the text" do
+        assert_not_contain("monkeys")
+      end
+      
+      it "should pass when not containing the regexp" do
+        assert_not_contain(/monkeys/)
+      end
+      
+      it "should throw an exception when the body does contain the text" do
+        lambda {
+          assert_not_contain("hello, world")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+      
+      it "should throw an exception when the body does contain the regexp" do
+        lambda {
+          assert_not_contain(/hello, world/)
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+  end
+
+  describe "#failure_message" do
+    it "should include the content string" do
+      hc = Webrat::Matchers::HasContent.new("hello, world!")
+      hc.matches?(@body)
+      
+      hc.failure_message.should include("\"hello, world!\"")
+    end
+    
+    it "should include the content regular expresson" do
+      hc = Webrat::Matchers::HasContent.new(/hello,\sworld!/)
+      hc.matches?(@body)
+      
+      hc.failure_message.should include("/hello,\\sworld!/")
+    end
+    
+    it "should include the element's inner content" do
+      hc = Webrat::Matchers::HasContent.new(/hello,\sworld!/)
+      hc.matches?(@body)
+      
+      hc.failure_message.should include("hello, world!")
+    end
+  end
+end

spec/public/matchers/have_selector_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "have_selector" do
+  include Webrat::Matchers
+  
+  before(:each) do
+    @body = <<-HTML
+      <div id='main'>
+        <div class='inner'>hello, world!</div>
+        <h2>Welcome "Bryan"</h2>
+        <h3>Welcome 'Bryan'</h3>
+        <h4>Welcome 'Bryan"</h4>
+        <ul>
+          <li>First</li>
+          <li>Second</li>
+        </ul>
+      </div>
+    HTML
+  end
+    
+  it "should be able to match a CSS selector" do
+    @body.should have_selector("div")
+  end
+  
+  it "should not match a CSS selector that does not exist" do
+    @body.should_not have_selector("p")
+  end
+  
+  describe "specifying attributes" do
+    it "should be able to specify the attributes of the tag" do
+      @body.should have_selector("div", :class => "inner")
+    end
+  end
+  
+  describe "specifying content" do
+    it "should be able to specify the content of the tag" do
+      @body.should have_selector("div", :content => "hello, world!")
+    end
+
+    it "should be able to specify the content of the tag with double quotes in it" do
+      @body.should have_selector("h2", :content => 'Welcome "Bryan"')
+    end
+
+    it "should be able to specify the content of the tag with single quotes in it" do
+      @body.should have_selector("h3", :content => "Welcome 'Bryan'")
+    end
+
+    it "should be able to specify the content of the tag with both kinds of quotes" do
+      @body.should have_selector("h4", :content => "Welcome 'Bryan\"")
+    end
+  end
+  
+  describe "specifying counts" do
+    it "should be able to specify the number of occurences of the tag" do
+      @body.should have_selector("li", :count => 2)
+    end
+
+    it "should not match if the count is wrong" do
+      lambda {
+        @body.should have_selector("li", :count => 3)
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+    end
+  end
+  
+  describe "specifying nested elements" do
+    it "should be able to loop over all the matched elements" do
+      @body.should have_selector("div") do |node|
+        node.first.name.should == "div"
+      end
+    end
+
+    it "should not match of any of the matchers in the block fail" do
+      lambda {
+        @body.should have_selector("div") do |node|
+          node.first.name.should == "p"
+        end
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+    end
+
+    it "should be able to use #have_selector in the block" do
+      @body.should have_selector("#main") do |node|
+        node.should have_selector(".inner")
+      end
+    end
+
+    it "should not match any parent tags in the block" do
+      lambda {
+        @body.should have_selector(".inner") do |node|
+          node.should have_selector("#main")
+        end
+      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+    end
+    
+    it "should work with items that have multiple child nodes" do
+      @body.should have_selector("ul") do |n|
+        n.should have_selector("li", :content => "First")
+        n.should have_selector("li", :content => "Second")
+      end
+    end
+  end
+  
+  describe "Test::Unit assertions" do
+    include Test::Unit::Assertions
+    
+    before(:each) do
+      require 'test/unit'
+      should_receive(:response_body).and_return @body
+    end
+    
+    describe "assert_have_selector" do
+      it "should pass when body contains the selection" do
+        assert_have_selector("div")
+      end
+      
+      it "should throw an exception when the body doesnt have matching selection" do
+        lambda {
+          assert_have_selector("p")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+    
+    describe "assert_have_not_selector" do
+      it "should pass when the body doesn't contan the selection" do
+        assert_have_no_selector("p")
+      end
+      
+      it "should throw an exception when the body does contain the selection" do
+        lambda {
+          assert_have_no_selector("div")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+  end
+  
+end

spec/public/matchers/have_tag_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "have_tag" do
+  include Webrat::Matchers
+  include Webrat::HaveTagMatcher
+  
+  before(:each) do
+    @body = <<-HTML
+      <div id='main'>
+        <div class='inner'>hello, world!</div>
+      </div>
+    HTML
+  end
+
+  it "should be an alias for have_selector" do
+    @body.should have_tag("div")
+  end
+  
+  describe "asserts for tags" do
+    include Test::Unit::Assertions
+    
+    before(:each) do
+      should_receive(:response_body).and_return @body
+      require 'test/unit'
+    end
+    
+    describe "assert_have_tag" do
+      it "should be an alias for assert_have_selector" do
+        assert_have_tag("div")
+      end
+    end
+    
+    describe "assert_have_no_tag" do
+      it "should be an alias for assert_have_no_selector" do
+        assert_have_no_tag("p")
+      end
+    end
+  end
+end

spec/public/matchers/have_xpath_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe "have_xpath" do
+  include Webrat::Matchers
+  
+  before(:each) do
+    @body = <<-HTML
+      <div id='main'>
+        <div class='inner'>hello, world!</div>
+        <h2>Welcome "Bryan"</h2>
+        <h3>Welcome 'Bryan'</h3>
+        <h4>Welcome 'Bryan"</h4>
+        <ul>
+          <li>First</li>
+          <li>Second</li>
+        </ul>
+      </div>
+    HTML
+  end
+  
+  it "should be able to match an XPATH" do
+    @body.should have_xpath("//div")
+  end
+  
+  it "should be able to match an XPATH with attributes" do
+    @body.should have_xpath("//div", :class => "inner")
+  end
+  
+  it "should be able to match an XPATH with content" do
+    @body.should have_xpath("//div", :content => "hello, world!")
+  end
+  
+  it "should not match an XPATH without content" do
+    @body.should_not have_xpath("//div", :content => "not present")
+  end
+  
+  it "should be able to match an XPATH with content and class" do
+    @body.should have_xpath("//div", :class => "inner", :content => "hello, world!")
+  end
+  
+  it "should not match an XPATH with content and wrong class" do
+    @body.should_not have_xpath("//div", :class => "outer", :content => "hello, world!")
+  end
+  
+  it "should not match an XPATH with wrong content and class" do
+    @body.should_not have_xpath("//div", :class => "inner", :content => "wrong")
+  end
+  
+  it "should not match an XPATH with wrong content and wrong class" do
+    @body.should_not have_xpath("//div", :class => "outer", :content => "wrong")
+  end
+  
+  it "should not match a XPATH that does not exist" do
+    @body.should_not have_xpath("//p")
+  end
+  
+  it "should be able to loop over all the matched elements" do
+    @body.should have_xpath("//div") do |node|
+      node.first.name.should == "div"
+    end
+  end
+  
+  it "should not match if any of the matchers in the block fail" do
+    lambda {
+      @body.should have_xpath("//div") do |node|
+        node.first.name.should == "p"
+      end
+    }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+  end
+  
+  it "should be able to use #have_xpath in the block" do
+    @body.should have_xpath("//div[@id='main']") do |node|
+      node.should have_xpath("./div[@class='inner']")
+    end
+  end
+  
+  it "should convert absolute paths to relative in the block" do
+    @body.should have_xpath("//div[@id='main']") do |node|
+      node.should have_xpath("//div[@class='inner']")
+    end
+  end
+  
+  it "should not match any parent tags in the block" do
+    lambda {
+      @body.should have_xpath("//div[@class='inner']") do |node|
+        node.should have_xpath("//div[@id='main']")
+      end
+    }.should raise_error(Spec::Expectations::ExpectationNotMetError)
+  end
+  
+  describe 'asserts for xpath' do
+    include Test::Unit::Assertions
+    
+    before(:each) do
+      should_receive(:response_body).and_return @body
+      require 'test/unit'
+    end
+    
+    describe "assert_have_xpath" do
+      it "should pass when body contains the selection" do
+        assert_have_xpath("//div")
+      end
+
+      it "should throw an exception when the body doesnt have matching xpath" do
+        lambda {
+          assert_have_xpath("//p")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+
+    describe "assert_have_no_xpath" do
+      it "should pass when the body doesn't contan the xpath" do
+        assert_have_no_xpath("//p")
+      end
+
+      it "should throw an exception when the body does contain the xpath" do
+        lambda {
+          assert_have_no_xpath("//div")
+        }.should raise_error(Test::Unit::AssertionFailedError)
+      end
+    end
+  end
+end

spec/public/matchers_spec.rb

@@ -1,333 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
-
-describe Webrat::Matchers do
-  include Webrat::Matchers
-  include Webrat::HaveTagMatcher
-  
-  before(:each) do
-    @body = <<-HTML
-      <div id='main'>
-        <div class='inner'>hello, world!</div>
-        <ul>
-          <li>First</li>
-          <li>Second</li>
-        </ul>
-      </div>
-    HTML
-  end
-  
-  describe "#have_xpath" do
-    it "should be able to match an XPATH" do
-      @body.should have_xpath("//div")
-    end
-    
-    it "should not match a XPATH that does not exist" do
-      @body.should_not have_xpath("//p")
-    end
-    
-    it "should be able to loop over all the matched elements" do
-      @body.should have_xpath("//div") do |node|
-        node.first.name.should == "div"
-      end
-    end
-    
-    it "should not match if any of the matchers in the block fail" do
-      lambda {
-        @body.should have_xpath("//div") do |node|
-          node.first.name.should == "p"
-        end
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    it "should be able to use #have_xpath in the block" do
-      @body.should have_xpath("//div[@id='main']") { |node| node.should have_xpath("./div[@class='inner']") }
-    end
-    
-    it "should convert absolute paths to relative in the block" do
-      @body.should have_xpath("//div[@id='main']") { |node| node.should have_xpath("//div[@class='inner']") }
-    end
-    
-    it "should not match any parent tags in the block" do
-      lambda {
-        @body.should have_xpath("//div[@class='inner']") { |node| node.should have_xpath("//div[@id='main']") }
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    describe 'asserts for xpath' do
-      include Test::Unit::Assertions
-       before(:each) do
-          should_receive(:response_body).and_return @body
-          require 'test/unit'
-        end
-        describe "assert_have_xpath" do
-          it "should pass when body contains the selection" do
-            assert_have_xpath("//div")
-          end
-
-          it "should throw an exception when the body doesnt have matching xpath" do
-            lambda {assert_have_xpath("//p")}.should raise_error(Test::Unit::AssertionFailedError)
-          end
-
-        end
-
-        describe "assert_have_no_xpath" do
-          it "should pass when the body doesn't contan the xpath" do
-            assert_have_no_xpath("//p")
-          end
-
-          it "should throw an exception when the body does contain the xpath" do
-            lambda {assert_have_no_xpath("//div")}.should raise_error(Test::Unit::AssertionFailedError)
-          end
-        end
-    end
-    
-  end
-  
-  describe "#have_selector" do
-    
-    it "should be able to match a CSS selector" do
-      @body.should have_selector("div")
-    end
-    
-    it "should not match a CSS selector that does not exist" do
-      @body.should_not have_selector("p")
-    end
-    
-    it "should be able to loop over all the matched elements" do
-      @body.should have_selector("div") do |node|
-        node.first.name.should == "div"
-      end
-    end
-    
-    it "should not match of any of the matchers in the block fail" do
-      lambda {
-        @body.should have_selector("div") do |node|
-          node.first.name.should == "p"
-        end
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    it "should be able to use #have_selector in the block" do
-      @body.should have_selector("#main") { |node| node.should have_selector(".inner") }
-    end
-    
-    it "should not match any parent tags in the block" do
-      lambda {
-        @body.should have_selector(".inner") { |node| node.should have_selector("#main") }
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    describe "asserts for selector," do
-      include Test::Unit::Assertions
-      before(:each) do
-        should_receive(:response_body).and_return @body
-        require 'test/unit'
-      end
-      describe "assert_have_selector" do
-        it "should pass when body contains the selection" do
-          assert_have_selector("div")
-        end
-        
-        it "should throw an exception when the body doesnt have matching selection" do
-          lambda {assert_have_selector("p")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-        
-      end
-      
-      describe "assert_have_not_selector" do
-        it "should pass when the body doesn't contan the selection" do
-          assert_have_no_selector("p")
-        end
-        
-        it "should throw an exception when the body does contain the selection" do
-          lambda {assert_have_no_selector("div")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-      end
-    end
-    
-  end
-  
-  describe "#have_tag" do
-    
-    it "should be able to match a tag" do
-      @body.should have_tag("div")
-    end
-    
-    it "should not match the tag when it should not match" do
-      @body.should_not have_tag("p")
-    end
-    
-    it "should be able to specify the content of the tag" do
-      @body.should have_tag("div", :content  => "hello, world!")
-    end
-    
-    it "should be able to specify the attributes of the tag" do
-      @body.should have_tag("div", :class => "inner")
-    end
-    
-    it "should be able to loop over all the matched elements" do
-      @body.should have_tag("div") do |node|
-        node.first.name.should == "div"
-      end
-    end
-    
-    it "should not match of any of the matchers in the block fail" do
-      lambda {
-        @body.should have_tag("div") do |node|
-          node.first.name.should == "p"
-        end
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    it "should be able to use #have_tag in the block" do
-      @body.should have_tag("div", :id => "main") { |node| node.should have_tag("div", :class => "inner") }
-    end
-    
-    it "should not match any parent tags in the block" do
-      lambda {
-        @body.should have_tag("div", :class => "inner") { |node| node.should have_tag("div", :id => "main") }
-      }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-    
-    it "should work with items that have multiple child nodes" do
-      @body.should have_tag("ul") { |n|
-        n.should have_tag("li", :content => "First")
-        n.should have_tag("li", :content => "Second")
-      }
-    end
-    
-    describe "asserts for tags," do
-      include Test::Unit::Assertions
-      before(:each) do
-        should_receive(:response_body).and_return @body
-        require 'test/unit'
-      end
-      describe "assert_have_tag" do
-        it "should pass when body contains the tag" do
-          assert_have_tag("div")
-        end
-        
-        it "should pass when finding with additional selectors" do
-          assert_have_tag("div", :class => "inner")
-        end
-        
-        
-        it "should throw an exception when the body doesnt have matching tag" do
-          lambda {assert_have_tag("p")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-        
-        it "should throw an exception when the body doens't have a tag matching the additional selector" do
-          lambda {assert_have_tag("div", :class => "nope")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-      end
-      
-      describe "assert_have_no_tag" do
-        it "should pass when the body doesn't contan the tag" do
-          assert_have_no_tag("p")
-        end
-        
-        it "should pass when the body doesn't contain the tag due to additional selectors missing" do
-          assert_have_no_tag("div", :class => "nope")
-        end
-        
-        it "should throw an exception when the body does contain the tag" do
-          lambda {assert_have_no_tag("div")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-        
-        it "should throw an exception when the body contains the tag with additional selectors" do
-          lambda {assert_have_no_tag("div", :class => "inner")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-      end
-    end
-    
-  end
-
-  describe Webrat::Matchers::HasContent do
-    include Webrat::Matchers
-
-    before(:each) do
-      @body = <<-EOF
-        <div id='main'>
-          <div class='inner'>hello, world!</div>
-        </div>
-      EOF
-    end
-    
-    describe "#matches?" do
-      it "should call element#contains? when the argument is a string" do
-        @body.should contain("hello, world!")
-      end
-      
-      it "should call element#matches? when the argument is a regular expression" do
-        @body.should contain(/hello, world/)
-      end
-    end
-    
-    describe "asserts for contains," do
-      include Test::Unit::Assertions
-      before(:each) do
-        should_receive(:response_body).and_return @body
-        require 'test/unit'
-      end
-      describe "assert_contain" do
-        it "should pass when containing the text" do
-          assert_contain("hello, world")
-        end
-        
-        it "should pass when containing the regexp" do
-          assert_contain(/hello, world/)
-        end
-        
-        it "should throw an exception when the body doesnt contain the text" do
-          lambda {assert_contain("monkeys")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-        
-        it "should throw an exception when the body doesnt contain the regexp" do
-          lambda {assert_contain(/monkeys/)}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-      end
-      
-      describe "assert_not_contain" do
-        it "should pass when not containing the text" do
-          assert_not_contain("monkeys")
-        end
-        
-        it "should pass when not containing the regexp" do
-          assert_not_contain(/monkeys/)
-        end
-        
-        it "should throw an exception when the body does contain the text" do
-          lambda {assert_not_contain("hello, world")}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-        
-        it "should throw an exception when the body does contain the regexp" do
-          lambda {assert_not_contain(/hello, world/)}.should raise_error(Test::Unit::AssertionFailedError)
-        end
-      end
-    end
-  
-    describe "#failure_message" do
-      
-      it "should include the content string" do
-        hc = Webrat::Matchers::HasContent.new("hello, world!")
-        hc.matches?(@body)
-        
-        hc.failure_message.should include("\"hello, world!\"")
-      end
-      
-      it "should include the content regular expresson" do
-        hc = Webrat::Matchers::HasContent.new(/hello,\sworld!/)
-        hc.matches?(@body)
-        
-        hc.failure_message.should include("/hello,\\sworld!/")
-      end
-      
-      it "should include the element's inner content" do
-        hc = Webrat::Matchers::HasContent.new(/hello,\sworld!/)
-        hc.matches?(@body)
-        
-        hc.failure_message.should include("hello, world!")
-      end
-    end
-  end
-end