github-migration/webrat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into atmos

Browse Source
This commit is contained in:
Bryan Helmkamp 2009-02-27 20:41:05 -05:00
commit 4115c99c9b
13 changed files with 553 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
History.txt
View File

@ -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)

2
Rakefile
View File

@ -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

2
lib/webrat.rb
View File

@ -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"

8
lib/webrat/core/matchers/have_content.rb
View File

@ -26,13 +26,17 @@ 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

46
lib/webrat/core/matchers/have_selector.rb
View File

@ -1,22 +1,44 @@
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
@ -28,24 +50,24 @@ module Webrat
#
# ==== Returns
# HaveSelector:: A new have selector matcher.
def have_selector(expected, &block)
HaveSelector.new(expected, &block)
def have_selector(name, attributes = {}, &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)
hs = HaveSelector.new(expected)
assert hs.matches?(response_body), hs.failure_message
def assert_have_selector(name, attributes = {}, &block)
matcher = HaveSelector.new(name, attributes, &block)
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)
hs = HaveSelector.new(expected)
assert !hs.matches?(response_body), hs.negative_failure_message
def assert_have_no_selector(name, attributes = {}, &block)
matcher = HaveSelector.new(name, attributes, &block)
assert !matcher.matches?(response_body), matcher.negative_failure_message
end
end

66
lib/webrat/core/matchers/have_tag.rb
View File

@ -1,70 +1,20 @@
module Webrat
require "webrat/core/matchers/have_selector"
module Webrat
module HaveTagMatcher
class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
# ==== Returns
# 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)
def have_tag(*args, &block)
have_selector(*args, &block)
end
alias_method :match_tag, :have_tag
# Asserts that the body of the response contains
# the supplied tag with the associated selectors
def assert_have_tag(name, attributes = {})
ht = HaveTag.new([name, attributes])
assert ht.matches?(response_body), ht.failure_message
def assert_have_tag(*args, &block)
assert_have_selector(*args, &block)
end
# Asserts that the body of the response
# does not contain the supplied string or regepx
def assert_have_no_tag(name, attributes = {})
ht = HaveTag.new([name, attributes])
assert !ht.matches?(response_body), ht.negative_failure_message
def assert_have_no_tag(*args, &block)
assert_have_no_selector(*args, &block)
end
end

90
lib/webrat/core/matchers/have_xpath.rb
View File

@ -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?
matches_nokogiri?(stringlike)
if @options[:count]
matched.size == @options[:count] && (!@block || @block.call(matched))
else
matches_rexml?(stringlike)
matched.any? && (!@block || @block.call(matched))
end
end
def matches_rexml?(stringlike)
def matches(stringlike)
if Webrat.configuration.parse_with_nokogiri?
nokogiri_matches(stringlike)
else
rexml_matches(stringlike)
end
end
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)
matched.any? && (!@block || @block.call(matched))
@document.xpath(*@query)
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
@ -67,6 +102,23 @@ module Webrat
def negative_failure_message
"expected following text to not match xpath #{@expected}:\n#{@document}"
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)
HaveXpath.new(expected, &block)
def have_xpath(expected, options = {}, &block)
HaveXpath.new(expected, options, &block)
end
alias_method :match_xpath, :have_xpath
def assert_have_xpath(expected, &block)
hs = HaveXpath.new(expected, &block)
def assert_have_xpath(expected, options = {}, &block)
hs = HaveXpath.new(expected, options, &block)
assert hs.matches?(response_body), hs.failure_message
end
def assert_have_no_xpath(expected, &block)
hs = HaveXpath.new(expected, &block)
def assert_have_no_xpath(expected, options = {}, &block)
hs = HaveXpath.new(expected, options, &block)
assert !hs.matches?(response_body), hs.negative_failure_message
end

2
lib/webrat/selenium/matchers/have_tag.rb
View File

@ -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

114
spec/public/matchers/contain_spec.rb Normal file
View File

@ -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

135
spec/public/matchers/have_selector_spec.rb Normal file
View File

@ -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

39
spec/public/matchers/have_tag_spec.rb Normal file
View File

@ -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

123
spec/public/matchers/have_xpath_spec.rb Normal file
View File

@ -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

333
spec/public/matchers_spec.rb
View File

@ -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