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

Merge branch 'master' of git://github.com/brynary/webrat into brynary/master 

Conflicts:
	Manifest.txt
	lib/webrat/mechanize/mechanize_session.rb
This commit is contained in:
Jeremy Burks 2008-11-11 19:47:49 -06:00
parent 255788e14b 82c6be380e
commit 92fde1d8de
70 changed files with 1563 additions and 857 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
History.txt
View File

@ -1,23 +1,49 @@
== Trunk
* Minor enhancements
* Raise Webrat::PageLoadError when a failure occurs so that application exceptions can be more accurately tested (Ryan Briones)
== 0.3.2 / 2008-11-08
* Minor enhancements
* Fixes behavior or have_tag when a block is passed. It passes the matched node(s) to the block for further specs again. (Carl Lerche)
== 0.3.1 / 2008-11-07
* Minor enhancements
* Use @_webrat_session instance variable instead of @session for Merb integration to avoid collisions
== 0.3.0 / 2008-11-07
* Major enhancements
* Added Merb support (Gwyn Morfey, Jeremy Burks, Rob Kaufman)
* Added #basic_auth(user, pass) to support HTTP Basic Auth (Aslak Hellesøy)
* Added support for Sinatra and Rack (Aslak Hellesøy)
* Added #within for manipulating the current page within a selector scope
* Add support for simulating SSL requests (Luke Melia)
* Add support for file fields via #attaches_file method (Kyle Hargraves)
* Added Merb support (Gwyn Morfey, Jeremy Burks, Rob Kaufman, Yehuda Katz)
* Added experimental Selenium support (Luke Melia)
* Add have_selector, have_xpath, have_tag and contain matchers from Merb
* Switch from Hpricot to Nokogiri for XML parsing (thanks, Aaron Patterson)
* Minor enhancements
* Added #within for manipulating the current page within a selector scope
* Add support for file fields via #attaches_file method (Rails only at the moment) (Kyle Hargraves)
* Add support for simulating SSL requests (Luke Melia)
* Added #basic_auth(user, pass) to support HTTP Basic Auth (Aslak Hellesøy)
* Added support for Sinatra and Rack (Aslak Hellesøy)
* Rename visits to visit, fills_in to fill_in, etc.
* Add #field_labeled for looking up form fields by label (David Chelimsky)
* Add #field_named and #field_with_id locators
* Don't depend on hoe anymore
* Return responses after sending requests
* Allow clicking links and buttons by a regular expression in Selenium (Luke Melia)
* Allow clicking links by a regular expression
* Add #http_accept for including MIME type HTTP "Accept" headers (Ryan Briones)
* Add #header to support inclusion of custom HTTP headers (Ryan Briones)
* Consider response codes 200-499 as successful enough to not raise a Webrat error (David Leal)
* Add #field_labeled for looking up form fields by label (David Chelimsky)
* Add Webrat.root method for cross-framework support (Krzysztof Zylawy)
* Add support for clicking areas of an image map (Alex Lang)
* Add should_see and should_not_see for verifying HTML response bodys
* Support relative links, including href="?foo=bar" (Kyle Hargraves)
* Separated Rails-specific code from the Webrat core to make it easier to use Webrat with other environments
* Alias visits as visit, clicks_link as click_link, etc. for better readability

1
Manifest.txt
View File

@ -26,7 +26,6 @@ lib/webrat/core/select_option.rb
lib/webrat/core/session.rb
lib/webrat/core/url_encoded_pair_parser.rb
lib/webrat/mechanize.rb
lib/webrat/mechanize/mechanize_session.rb
lib/webrat/merb.rb
lib/webrat/rack/rack_session.rb
lib/webrat/rails.rb

7
README.txt
View File

@ -78,13 +78,6 @@ In your stories/helper.rb:
You could also unpack the gem into vendor/plugins.
=== Requirements
- Rails >= 1.2.6
- Hpricot >= 0.6
- Rails integration tests in Test::Unit _or_
- Cucumber
=== Authors
- Maintained by [Bryan Helmkamp](mailto:bryan@brynary.com)

82
Rakefile
View File

@ -1,43 +1,52 @@
require 'rubygems'
require 'hoe'
require "rake/gempackagetask"
require 'rake/rdoctask'
require "rake/clean"
require 'spec'
require 'spec/rake/spectask'
require 'spec/rake/verify_rcov'
require './lib/webrat.rb'
Hoe.new('webrat', Webrat::VERSION) do |p|
p.rubyforge_name = 'webrat'
p.summary = 'Ruby Acceptance Testing for Web applications'
p.developer "Bryan Helmkamp", "bryan@brynary.com"
p.developer "Seth Fitzsimmons", "seth@mojodna.net"
p.description = p.paragraphs_of('README.txt', 4..6).join("\n\n")
p.url = p.paragraphs_of('README.txt', 1).first.split("\n").first.strip
p.changes = p.paragraphs_of('History.txt', 0..3).join("\n\n")
##############################################################################
# Package && release
##############################################################################
spec = Gem::Specification.new do |s|
s.name = "webrat"
s.version = Webrat::VERSION
s.platform = Gem::Platform::RUBY
s.author = "Bryan Helmkamp"
s.email = "bryan" + "@" + "brynary.com"
s.homepage = "http://github.com/brynary/webrat"
s.summary = "Webrat. Ruby Acceptance Testing for Web applications"
s.bindir = "bin"
s.description = s.summary
s.require_path = "lib"
s.files = %w(History.txt init.rb install.rb MIT-LICENSE.txt README.txt Rakefile TODO.txt) + Dir["lib/**/*"]
p.extra_deps << ["hpricot", ">= 0.6"]
p.remote_rdoc_dir = '' # Release to root
# rdoc
s.has_rdoc = true
s.extra_rdoc_files = %w(README.txt MIT-LICENSE.txt)
# Dependencies
s.add_dependency "nokogiri", ">= 1.0.3"
end
Rake::GemPackageTask.new(spec) do |package|
package.gem_spec = spec
end
desc 'Show information about the gem.'
task :debug_gem do
puts spec.to_ruby
end
CLEAN.include ["pkg", "*.gem", "doc", "ri", "coverage"]
desc "Upload rdoc to brynary.com"
task :publish_rdoc => :docs do
sh "scp -r doc/ brynary.com:/apps/uploads/webrat"
end
Rake::TaskManager.class_eval do
def remove_task(task_name)
@tasks.delete(task_name.to_s)
end
end
def remove_task(task_name)
Rake.application.remove_task(task_name)
end
remove_task "test"
remove_task "test_deps"
desc "Run API and Core specs"
Spec::Rake::SpecTask.new do |t|
t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
@ -54,12 +63,27 @@ Spec::Rake::SpecTask.new(:rcov) do |t|
end
end
require 'spec/rake/verify_rcov'
RCov::VerifyTask.new(:verify_rcov => :rcov) do |t|
t.threshold = 96.2 # Make sure you have rcov 0.7 or higher!
end
remove_task "default"
task :default do
Rake::Task["verify_rcov"].invoke
end
desc 'Install the package as a gem.'
task :install_gem => [:clean, :package] do
gem = Dir['pkg/*.gem'].first
sh "sudo gem install --local #{gem}"
end
Rake::RDocTask.new(:docs) do |rd|
rd.main = "README.txt"
rd.rdoc_dir = 'doc'
files = spec.files.grep(/^(lib|bin|ext)|txt$/)
files -= ["TODO.txt"]
files -= files.grep(/\.js$/)
rd.rdoc_files = files.uniq
title = "webrat-#{Webrat::VERSION} Documentation"
rd.options << "-t #{title}"
end

13
TODO.txt
View File

@ -1,7 +1,10 @@
Run tests in separate processes to eliminate constant-level dependencies
Add rake tasks for selenium runs
Add tests for selenium
Add tests for locator strategies
Use Webrat::Methods for Rails integration
Get file uploads workign with merb
Fix #within scoping for forms that exist outside the scope
Figure out what the deal is with #select not working
Restore SSL support for Rails (See 73d3b72108254c0f1ad00e63f8e712115cc8ca7c)
Full support for multiple forms on a page
Track the current form based on the location of the last manipulated input, use this as a default for clicks_button
Make current_url work with redirections
Support for a hash mapping page names to page URLs
Track the current form based on the location of the last manipulated input, use this as a default for click_button
Verify SSL support in Rails and Merb

28
lib/webrat.rb
View File

@ -3,16 +3,32 @@ require "rubygems"
$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
module Webrat
VERSION = '0.2.2'
VERSION = '0.3.2'
def self.root
def self.root #:nodoc:
defined?(RAILS_ROOT) ? RAILS_ROOT : Merb.root
end
class WebratError < StandardError
end
end
# We need Nokogiri's CSS to XPath support, even if using REXML
require "nokogiri/css"
# Require nokogiri and fall back on rexml
begin
require "nokogiri"
require "webrat/core/nokogiri"
rescue LoadError => e
require "rexml/document"
warn("Standard REXML library is slow. Please consider installing nokogiri.\nUse \"sudo gem install nokogiri\"")
end
# require "webrat/merb/param_parser"
# require "webrat/merb/url_encoded_pair_parser"
require "webrat/core"
require "webrat/rails" if defined?(RAILS_ENV)
require "webrat/merb" if defined?(Merb)
# TODO: This is probably not a good idea.
# Probably better for webrat users to require "webrat/rails" etc. directly
if defined?(RAILS_ENV)
require "webrat/rails"
end

3
lib/webrat/core.rb
View File

@ -1,3 +1,4 @@
require "webrat/core/nokogiri"
require "webrat/core/logging"
require "webrat/core/flunk"
require "webrat/core/param_parser"
@ -8,3 +9,5 @@ require "webrat/core/area"
require "webrat/core/label"
require "webrat/core/select_option"
require "webrat/core/session"
require "webrat/core/methods"
require "webrat/core/matchers"

2
lib/webrat/core/area.rb
View File

@ -1,5 +1,5 @@
module Webrat
class Area
class Area #:nodoc:
def initialize(session, element)
@session = session

27
lib/webrat/core/assertions.rb
View File

@ -1,27 +0,0 @@
module Webrat
module Assertions
def should_see(text_or_regexp)
case text_or_regexp
when Regexp
return if scoped_html.match(text_or_regexp)
else
return if scoped_html.include?(text_or_regexp)
end
flunk("Should see #{text_or_regexp.inspect} but didn't")
end
def should_not_see(text_or_regexp)
case text_or_regexp
when Regexp
return unless scoped_html.match(text_or_regexp)
else
return unless scoped_html.include?(text_or_regexp)
end
flunk("Should not see #{text_or_regexp.inspect} but did")
end
end
end

58
lib/webrat/core/field.rb
View File

@ -3,7 +3,7 @@ require "webrat/core_extensions/blank"
require "webrat/core_extensions/nil_to_param"
module Webrat
class Field
class Field #:nodoc:
def self.class_for_element(element)
if element.name == "input"
@ -59,7 +59,16 @@ module Webrat
def to_param
return nil if disabled?
param_parser.parse_query_parameters("#{name}=#{escaped_value}")
key_and_value = "#{name}=#{escaped_value}"
if defined?(CGIMethods)
CGIMethods.parse_query_parameters(key_and_value)
elsif defined?(ActionController::AbstractRequest)
ActionController::AbstractRequest.parse_query_parameters(key_and_value)
else
::Merb::Parse.query(key_and_value)
end
end
def set(value)
@ -102,7 +111,7 @@ module Webrat
end
unless id.blank?
@label_elements += @form.element / "label[@for=#{id}]"
@label_elements += @form.element.search("label[@for='#{id}']")
end
@label_elements
@ -112,16 +121,6 @@ module Webrat
@element["value"]
end
def param_parser
if defined?(CGIMethods)
CGIMethods
elsif defined?(ActionController::AbstractRequest)
ActionController::AbstractRequest
else
Webrat::ParamParser #used for Merb
end
end
def replace_param_value(params, oval, nval)
output = Hash.new
params.each do |key, value|
@ -139,10 +138,10 @@ module Webrat
end
end
class ButtonField < Field
class ButtonField < Field #:nodoc:
def matches_text?(text)
@element.innerHTML =~ /#{Regexp.escape(text.to_s)}/i
@element.inner_html =~ /#{Regexp.escape(text.to_s)}/i
end
def matches_value?(value)
@ -166,13 +165,13 @@ module Webrat
end
class HiddenField < Field
class HiddenField < Field #:nodoc:
def to_param
if collection_name?
super
else
checkbox_with_same_name = @form.find_field(name, CheckboxField)
checkbox_with_same_name = @form.field(name, CheckboxField)
if checkbox_with_same_name.to_param.blank?
super
@ -190,7 +189,7 @@ module Webrat
end
class CheckboxField < Field
class CheckboxField < Field #:nodoc:
def to_param
return nil if @value.nil?
@ -223,10 +222,10 @@ module Webrat
end
class PasswordField < Field
class PasswordField < Field #:nodoc:
end
class RadioField < Field
class RadioField < Field #:nodoc:
def to_param
return nil if @value.nil?
@ -258,7 +257,7 @@ module Webrat
end
class TextareaField < Field
class TextareaField < Field #:nodoc:
protected
@ -268,7 +267,7 @@ module Webrat
end
class FileField < Field
class FileField < Field #:nodoc:
attr_accessor :content_type
@ -297,13 +296,13 @@ module Webrat
end
class TextField < Field
class TextField < Field #:nodoc:
end
class ResetField < Field
class ResetField < Field #:nodoc:
end
class SelectField < Field
class SelectField < Field #:nodoc:
def find_option(text)
options.detect { |o| o.matches_text?(text) }
@ -312,11 +311,12 @@ module Webrat
protected
def default_value
selected_options = @element / "option[@selected='selected']"
selected_options = @element / "option:first" if selected_options.empty?
selected_options = @element.search(".//option[@selected='selected']")
selected_options = @element.search(".//option[position() = 1]") if selected_options.empty?
selected_options.map do |option|
return "" if option.nil?
option["value"] || option.innerHTML
option["value"] || option.inner_html
end
end
@ -325,7 +325,7 @@ module Webrat
end
def option_elements
(@element / "option")
@element.search(".//option")
end
end

2
lib/webrat/core/flunk.rb
View File

@ -1,6 +1,6 @@
module Flunk
def flunk(message)
def flunk(message) #:nodoc:
raise message
end

33
lib/webrat/core/form.rb
View File

@ -2,7 +2,7 @@ require "webrat/core/field"
require "webrat/core_extensions/blank"
module Webrat
class Form
class Form #:nodoc:
attr_reader :element
def initialize(session, element)
@ -11,12 +11,10 @@ module Webrat
@fields = nil
end
def find_field(id_or_name_or_label, *field_types)
possible_fields = fields_by_type(field_types)
find_field_by_id(possible_fields, id_or_name_or_label) ||
find_field_by_name(possible_fields, id_or_name_or_label) ||
find_field_by_label(possible_fields, id_or_name_or_label) ||
def field(locator, *field_types)
field_with_id(locator, *field_types) ||
field_named(locator, *field_types) ||
field_labeled(locator, *field_types) ||
nil
end
@ -41,7 +39,7 @@ module Webrat
def fields
return @fields if @fields
@fields = (@element / "button, input, textarea, select").collect do |field_element|
@fields = (@element.search(".//button", ".//input", ".//textarea", ".//select")).collect do |field_element|
Field.class_for_element(field_element).new(self, field_element)
end
end
@ -50,25 +48,32 @@ module Webrat
@session.request_page(form_action, form_method, params)
end
protected
def find_field_by_id(possible_fields, id)
def field_with_id(id, *field_types)
possible_fields = fields_by_type(field_types)
possible_fields.detect { |possible_field| possible_field.matches_id?(id) }
end
def find_field_by_name(possible_fields, name)
def field_named(name, *field_types)
possible_fields = fields_by_type(field_types)
possible_fields.detect { |possible_field| possible_field.matches_name?(name) }
end
def find_field_by_label(possible_fields, label)
def field_labeled(label, *field_types)
possible_fields = fields_by_type(field_types)
matching_fields = possible_fields.select do |possible_field|
possible_field.matches_label?(label)
end
matching_fields.min { |a, b| a.label_text.length <=> b.label_text.length }
end
protected
def fields_by_type(field_types)
fields.select { |f| field_types.include?(f.class) }
if field_types.any?
fields.select { |f| field_types.include?(f.class) }
else
fields
end
end
def params

4
lib/webrat/core/label.rb
View File

@ -1,5 +1,5 @@
module Webrat
class Label
class Label #:nodoc:
def initialize(field, element)
@field = field
@ -11,7 +11,7 @@ module Webrat
end
def text
@element.innerText
@element.inner_text
end
end

14
lib/webrat/core/link.rb
View File

@ -1,7 +1,7 @@
require "webrat/core_extensions/blank"
module Webrat
class Link
class Link #:nodoc:
def initialize(session, element)
@session = session
@ -22,13 +22,19 @@ module Webrat
end
def matches_text?(link_text)
html = text.gsub('&nbsp;',' ')
matcher = /#{Regexp.escape(link_text.to_s)}/i
html = text.gsub('&#xA0;',' ')
if link_text.is_a?(Regexp)
matcher = link_text
else
matcher = /#{Regexp.escape(link_text.to_s)}/i
end
html =~ matcher || title =~ matcher
end
def text
@element.innerHTML
@element.inner_html
end
protected

92
lib/webrat/core/locators.rb Normal file
View File

@ -0,0 +1,92 @@
require "webrat/core_extensions/detect_mapped"
module Webrat
module Locators
def field(*args)
# This is the default locator strategy
find_field_with_id(*args) ||
find_field_named(*args) ||
field_labeled(*args) ||
flunk("Could not find field: #{args.inspect}")
end
def field_labeled(label, *field_types)
find_field_labeled(label, *field_types) ||
flunk("Could not find field labeled #{label.inspect}")
end
def field_named(name, *field_types)
find_field_named(name, *field_types) ||
flunk("Could not find field named #{name.inspect}")
end
def field_with_id(id, *field_types)
find_field_with_id(id, *field_types) ||
flunk("Could not find field with id #{id.inspect}")
end
def find_field_labeled(label, *field_types) #:nodoc:
forms.detect_mapped do |form|
form.field_labeled(label, *field_types)
end
end
def find_field_named(name, *field_types) #:nodoc:
forms.detect_mapped do |form|
form.field_named(name, *field_types)
end
end
def find_field_with_id(id, *field_types) #:nodoc:
forms.detect_mapped do |form|
form.field_with_id(id, *field_types)
end
end
def find_select_option(option_text, id_or_name_or_label) #:nodoc:
if id_or_name_or_label
field = field(id_or_name_or_label, SelectField)
return field.find_option(option_text)
else
select_option = forms.detect_mapped do |form|
form.find_select_option(option_text)
end
return select_option if select_option
end
flunk("Could not find option #{option_text.inspect}")
end
def find_button(value) #:nodoc:
button = forms.detect_mapped do |form|
form.find_button(value)
end
if button
return button
else
flunk("Could not find button #{value.inspect}")
end
end
def find_area(area_name) #:nodoc:
areas.detect { |area| area.matches_text?(area_name) } ||
flunk("Could not find area with name #{area_name}")
end
def find_link(text) #:nodoc:
matching_links = links.select do |possible_link|
possible_link.matches_text?(text)
end
if matching_links.any?
matching_links.min { |a, b| a.text.length <=> b.text.length }
else
flunk("Could not find link with text #{text.inspect}")
end
end
end
end

2
lib/webrat/core/logging.rb
View File

@ -1,5 +1,5 @@
module Webrat
module Logging
module Logging #:nodoc:
def warn_log(message) # :nodoc:
return unless logger

4
lib/webrat/core/matchers.rb Normal file
View File

@ -0,0 +1,4 @@
require "webrat/core/matchers/have_xpath"
require "webrat/core/matchers/have_selector"
require "webrat/core/matchers/have_tag"
require "webrat/core/matchers/have_content"

94
lib/webrat/core/matchers/have_content.rb Normal file
View File

@ -0,0 +1,94 @@
module Webrat
module Matchers
class HasContent #:nodoc:
def initialize(content)
@content = content
end
def matches?(stringlike)
if defined?(Nokogiri::XML)
matches_nokogiri?(stringlike)
else
matches_rexml?(stringlike)
end
end
def matches_rexml?(stringlike)
@document = rexml_document(stringlike)
@element = @document.inner_text
case @content
when String
@element.include?(@content)
when Regexp
@element.match(@content)
end
end
def matches_nokogiri?(stringlike)
@document = Webrat.nokogiri_document(stringlike)
@element = @document.inner_text
case @content
when String
@element.include?(@content)
when Regexp
@element.match(@content)
end
end
def rexml_document(stringlike)
stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
case stringlike
when REXML::Document
stringlike.root
when REXML::Node
stringlike
when StringIO, String
begin
REXML::Document.new(stringlike.to_s).root
rescue REXML::ParseException => e
if e.message.include?("second root element")
REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
else
raise e
end
end
end
end
# ==== Returns
# String:: The failure message.
def failure_message
"expected the following element's content to #{content_message}:\n#{@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}"
end
def content_message
case @content
when String
"include \"#{@content}\""
when Regexp
"match #{@content.inspect}"
end
end
end
# Matches the contents of an HTML document with
# whatever string is supplied
#
# ---
# @api public
def contain(content)
HasContent.new(content)
end
end
end

39
lib/webrat/core/matchers/have_selector.rb Normal file
View File

@ -0,0 +1,39 @@
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}"
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}"
end
def query
Nokogiri::CSS::Parser.parse(*super).map { |ast| ast.to_xpath }
end
end
# Matches HTML content against a CSS 3 selector.
#
# ==== Parameters
# expected<String>:: The CSS selector to look for.
#
# ==== Returns
# HaveSelector:: A new have selector matcher.
# ---
# @api public
def have_selector(expected, &block)
HaveSelector.new(expected, &block)
end
alias_method :match_selector, :have_selector
end
end

58
lib/webrat/core/matchers/have_tag.rb Normal file
View File

@ -0,0 +1,58 @@
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)
end
alias_method :match_tag, :have_tag
end
end

85
lib/webrat/core/matchers/have_xpath.rb Normal file
View File

@ -0,0 +1,85 @@
require "webrat/core/nokogiri"
require "webrat/core/rexml"
module Webrat
module Matchers
class HaveXpath #:nodoc:
def initialize(expected, &block)
@expected = expected
@block = block
end
def matches?(stringlike)
if defined?(Nokogiri::XML)
matches_nokogiri?(stringlike)
else
matches_rexml?(stringlike)
end
end
def matches_rexml?(stringlike)
if REXML::Node === stringlike || Array === stringlike
@query = query.map { |q| q.gsub(%r'//', './') }
else
@query = query
end
@document = Webrat.rexml_document(stringlike)
matched = @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)
if Nokogiri::XML::NodeSet === stringlike
@query = query.map { |q| q.gsub(%r'//', './') }
else
@query = query
end
@document = Webrat.nokogiri_document(stringlike)
matched = @document.xpath(*@query)
matched.any? && (!@block || @block.call(matched))
end
def query
[@expected].flatten.compact
end
# ==== Returns
# String:: The failure message.
def failure_message
"expected following text to match xpath #{@expected}:\n#{@document}"
end
# ==== Returns
# 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
# Matches HTML content against an XPath query
#
# ==== Parameters
# expected<String>:: The XPath query to look for.
#
# ==== Returns
# HaveXpath:: A new have xpath matcher.
# ---
# @api public
def have_xpath(expected, &block)
HaveXpath.new(expected, &block)
end
alias_method :match_xpath, :have_xpath
end
end

44
lib/webrat/core/methods.rb Normal file
View File

@ -0,0 +1,44 @@
module Webrat
module Methods #:nodoc:
def self.delegate_to_session(*meths)
meths.each do |meth|
self.class_eval <<-RUBY
def #{meth}(*args, &blk)
@_webrat_session ||= ::Webrat::MerbSession.new
@_webrat_session.#{meth}(*args, &blk)
end
RUBY
end
end
# all of these methods delegate to the @session, which should
# be created transparently.
#
# Note that when using Webrat, #request also uses @session, so
# that #request and webrat native functions behave interchangably
delegate_to_session \
:visits, :visit,
:within,
:header, :http_accept, :basic_auth,
:save_and_open_page,
:fill_in,
:check,
:uncheck,
:choose,
:select,
:attach_file,
:cookies,
:response,
:current_page,
:current_url,
:click_link,
:click_area,
:click_button,
:reload, :reloads,
:clicks_link_within,
:field_labeled
end
end

44
lib/webrat/core/nokogiri.rb Normal file
View File

@ -0,0 +1,44 @@
require "webrat/core_extensions/meta_class"
module Webrat
def self.nokogiri_document(stringlike) #:nodoc:
return stringlike.dom if stringlike.respond_to?(:dom)
if Nokogiri::HTML::Document === stringlike
stringlike
elsif Nokogiri::XML::NodeSet === stringlike
stringlike
elsif StringIO === stringlike
Nokogiri::HTML(stringlike.string)
elsif stringlike.respond_to?(:body)
Nokogiri::HTML(stringlike.body.to_s)
else
Nokogiri::HTML(stringlike.to_s)
end
end
def self.define_dom_method(object, dom) #:nodoc:
object.meta_class.send(:define_method, :dom) do
dom
end
end
end
module Nokogiri
module CSS
class XPathVisitor
def visit_pseudo_class_text(node) #:nodoc:
"@type='text'"
end
def visit_pseudo_class_password(node) #:nodoc:
"@type='password'"
end
end
end
end

24
lib/webrat/core/rexml.rb Normal file
View File

@ -0,0 +1,24 @@
module Webrat
def self.rexml_document(stringlike)
stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
case stringlike
when REXML::Document
stringlike.root
when REXML::Node, Array
stringlike
else
begin
REXML::Document.new(stringlike.to_s).root
rescue REXML::ParseException => e
if e.message.include?("second root element")
REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
else
raise e
end
end
end
end
end

206
lib/webrat/core/scope.rb
View File

@ -1,69 +1,81 @@
require "hpricot"
require "webrat/core/form"
require "webrat/core/assertions"
require "webrat/core/locators"
module Webrat
class Scope
include Logging
include Flunk
include Assertions
include Locators
def initialize(session, html, selector = nil)
@session = session
@html = html
@selector = selector
def self.from_page(session, response, response_body) #:nodoc:
new(session) do
@response = response
@response_body = response_body
end
end
def self.from_scope(session, scope, selector) #:nodoc:
new(session) do
@scope = scope
@selector = selector
end
end
def initialize(session, &block) #:nodoc:
@session = session
instance_eval(&block) if block_given?
end
# Verifies an input field or textarea exists on the current page, and stores a value for
# it which will be sent when the form is submitted.
#
# Examples:
# fills_in "Email", :with => "user@example.com"
# fills_in "user[email]", :with => "user@example.com"
# fill_in "Email", :with => "user@example.com"
# fill_in "user[email]", :with => "user@example.com"
#
# The field value is required, and must be specified in <tt>options[:with]</tt>.
# <tt>field</tt> can be either the value of a name attribute (i.e. <tt>user[email]</tt>)
# or the text inside a <tt><label></tt> element that points at the <tt><input></tt> field.
def fills_in(id_or_name_or_label, options = {})
field = find_field(id_or_name_or_label, TextField, TextareaField, PasswordField)
def fill_in(field_locator, options = {})
field = locate_field(field_locator, TextField, TextareaField, PasswordField)
field.raise_error_if_disabled
field.set(options[:with])
end
alias_method :fill_in, :fills_in
alias_method :fills_in, :fill_in
# Verifies that an input checkbox exists on the current page and marks it
# as checked, so that the value will be submitted with the form.
#
# Example:
# checks 'Remember Me'
def checks(id_or_name_or_label)
find_field(id_or_name_or_label, CheckboxField).check
# check 'Remember Me'
def check(field_locator)
locate_field(field_locator, CheckboxField).check
end
alias_method :check, :checks
alias_method :checks, :check
# Verifies that an input checkbox exists on the current page and marks it
# as unchecked, so that the value will not be submitted with the form.
#
# Example:
# unchecks 'Remember Me'
def unchecks(id_or_name_or_label)
find_field(id_or_name_or_label, CheckboxField).uncheck
# uncheck 'Remember Me'
def uncheck(field_locator)
locate_field(field_locator, CheckboxField).uncheck
end
alias_method :uncheck, :unchecks
alias_method :unchecks, :uncheck
# Verifies that an input radio button exists on the current page and marks it
# as checked, so that the value will be submitted with the form.
#
# Example:
# chooses 'First Option'
def chooses(label)
find_field(label, RadioField).choose
# choose 'First Option'
def choose(field_locator)
locate_field(field_locator, RadioField).choose
end
alias_method :choose, :chooses
alias_method :chooses, :choose
# Verifies that a an option element exists on the current page with the specified
# text. You can optionally restrict the search to a specific select list by
@ -87,22 +99,22 @@ module Webrat
# Example:
# attaches_file "Resume", "/path/to/the/resume.txt"
# attaches_file "Photo", "/path/to/the/image.png", "image/png"
def attaches_file(id_or_name_or_label, path, content_type = nil)
find_field(id_or_name_or_label, FileField).set(path, content_type)
def attach_file(field_locator, path, content_type = nil)
locate_field(field_locator, FileField).set(path, content_type)
end
alias_method :attach_file, :attaches_file
alias_method :attaches_file, :attach_file
def clicks_area(area_name)
def click_area(area_name)
find_area(area_name).click
end
alias_method :click_area, :clicks_area
alias_method :clicks_area, :click_area
# Issues a request for the URL pointed to by a link on the current page,
# follows any redirects, and verifies the final page load was successful.
#
# clicks_link has very basic support for detecting Rails-generated
# click_link has very basic support for detecting Rails-generated
# JavaScript onclick handlers for PUT, POST and DELETE links, as well as
# CSRF authenticity tokens if they are present.
#
@ -112,139 +124,81 @@ module Webrat
# for making the link request
#
# Example:
# clicks_link "Sign up"
# click_link "Sign up"
#
# clicks_link "Sign up", :javascript => false
# click_link "Sign up", :javascript => false
#
# clicks_link "Sign up", :method => :put
def clicks_link(link_text, options = {})
# click_link "Sign up", :method => :put
def click_link(link_text, options = {})
find_link(link_text).click(options)
end
alias_method :click_link, :clicks_link
def clicks_get_link(link_text) # :nodoc:
clicks_link link_text, :method => :get
end
alias_method :click_get_link, :clicks_get_link
def clicks_delete_link(link_text) # :nodoc:
clicks_link link_text, :method => :delete
end
alias_method :click_delete_link, :clicks_delete_link
def clicks_post_link(link_text) # :nodoc:
clicks_link link_text, :method => :post
end
alias_method :click_post_link, :clicks_post_link
def clicks_put_link(link_text) # :nodoc:
clicks_link link_text, :method => :put
end
alias_method :click_put_link, :clicks_put_link
alias_method :clicks_link, :click_link
# Verifies that a submit button exists for the form, then submits the form, follows
# any redirects, and verifies the final page was successful.
#
# Example:
# clicks_button "Login"
# clicks_button
# click_button "Login"
# click_button
#
# The URL and HTTP method for the form submission are automatically read from the
# <tt>action</tt> and <tt>method</tt> attributes of the <tt><form></tt> element.
def clicks_button(value = nil)
def click_button(value = nil)
find_button(value).click
end
alias_method :click_button, :clicks_button
alias_method :clicks_button, :click_button
def dom # :nodoc:
@dom ||= Hpricot(scoped_html)
end
def field_labeled(label)
find_field(label, TextField, TextareaField, CheckboxField, RadioField, HiddenField)
return @dom if @dom
if @selector
@dom = scoped_dom
else
@dom = page_dom
end
return @dom
end
protected
def scoped_html
@scoped_html ||= begin
if @selector
(Hpricot(@html) / @selector).first.to_html
else
@html
end
end
def page_dom #:nodoc:
return @response.dom if @response.respond_to?(:dom)
dom = Webrat.nokogiri_document(@response_body)
Webrat.define_dom_method(@response, dom)
return dom
end
def find_select_option(option_text, id_or_name_or_label)
if id_or_name_or_label
field = find_field(id_or_name_or_label, SelectField)
return field.find_option(option_text)
def scoped_dom #:nodoc:
Webrat.nokogiri_document(@scope.dom.search(@selector).first.to_html)
end
def locate_field(field_locator, *field_types) #:nodoc:
if field_locator.is_a?(Field)
field_locator
else
forms.each do |form|
result = form.find_select_option(option_text)
return result if result
end
field(field_locator, *field_types)
end
flunk("Could not find option #{option_text.inspect}")
end
def find_button(value)
forms.each do |form|
button = form.find_button(value)
return button if button
end
flunk("Could not find button #{value.inspect}")
end
def find_area(area_name)
areas.select{|area| area.matches_text?(area_name)}.first || flunk("Could not find area with name #{area_name}")
end
def areas
(dom / "area").map do |element|
def areas #:nodoc:
dom.search("area").map do |element|
Area.new(@session, element)
end
end
def find_link(text, selector = nil)
matching_links = links_within(selector).select do |possible_link|
possible_link.matches_text?(text)
end
if matching_links.any?
matching_links.min { |a, b| a.text.length <=> b.text.length }
else
flunk("Could not find link with text #{text.inspect}")
end
end
def find_field(id_or_name_or_label, *field_types)
forms.each do |form|
result = form.find_field(id_or_name_or_label, *field_types)
return result if result
end
flunk("Could not find #{field_types.inspect}: #{id_or_name_or_label.inspect}")
end
def links_within(selector)
(dom / selector / "a[@href]").map do |link_element|
def links #:nodoc:
dom.search("a[@href]").map do |link_element|
Link.new(@session, link_element)
end
end
def forms
def forms #:nodoc:
return @forms if @forms
@forms = (dom / "form").map do |form_element|
@forms = dom.search("form").map do |form_element|
Form.new(@session, form_element)
end
end

8
lib/webrat/core/select_option.rb
View File

@ -1,5 +1,5 @@
module Webrat
class SelectOption
class SelectOption #:nodoc:
def initialize(select, element)
@select = select
@ -8,9 +8,9 @@ module Webrat
def matches_text?(text)
if text.is_a?(Regexp)
@element.innerHTML =~ text
@element.inner_html =~ text
else
@element.innerHTML == text.to_s
@element.inner_html == text.to_s
end
end
@ -22,7 +22,7 @@ module Webrat
protected
def value
@element["value"] || @element.innerHTML
@element["value"] || @element.inner_html
end
end

74
lib/webrat/core/session.rb
View File

@ -4,14 +4,16 @@ require "ostruct"
require "webrat/core/mime"
module Webrat
class PageLoadError < WebratError
end
class Session
extend Forwardable
include Logging
include Flunk
attr_reader :current_url
def initialize
def initialize #:nodoc:
@http_method = :get
@data = {}
@default_headers = {}
@ -35,12 +37,12 @@ module Webrat
open_in_browser(filename)
end
def current_dom
def current_dom #:nodoc:
current_scope.dom
end
# For backwards compatibility -- removing in 1.0
def current_page
def current_page #:nodoc:
page = OpenStruct.new
page.url = @current_url
page.http_method = @http_method
@ -48,11 +50,11 @@ module Webrat
page
end
def doc_root
def doc_root #:nodoc:
nil
end
def saved_page_dir
def saved_page_dir #:nodoc:
File.expand_path(".")
end
@ -69,11 +71,11 @@ module Webrat
header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
end
def headers
def headers #:nodoc:
@default_headers.dup.merge(@custom_headers.dup)
end
def request_page(url, http_method, data)
def request_page(url, http_method, data) #:nodoc:
h = headers
h['HTTP_REFERER'] = @current_url if @current_url
@ -85,24 +87,27 @@ module Webrat
end
save_and_open_page if exception_caught?
flunk("Page load was not successful (Code: #{response_code.inspect}):\n#{formatted_error}") unless success_code?
raise PageLoadError.new("Page load was not successful (Code: #{response_code.inspect}):\n#{formatted_error}") unless success_code?
@scope = nil
@_scopes = nil
@_page_scope = nil
@current_url = url
@http_method = http_method
@data = data
return response
end
def success_code?
def success_code? #:nodoc:
(200..499).include?(response_code)
end
def exception_caught?
def exception_caught? #:nodoc:
response_body =~ /Exception caught/
end
def current_scope
@scope ||= Scope.new(self, response_body)
def current_scope #:nodoc:
scopes.last || page_scope
end
# Reloads the last page requested. Note that this will resubmit forms
@ -117,46 +122,57 @@ module Webrat
alias_method :reload, :reloads
# Works like clicks_link, but only looks for the link text within a given selector
# Works like click_link, but only looks for the link text within a given selector
#
# Example:
# clicks_link_within "#user_12", "Vote"
def clicks_link_within(selector, link_text)
within(selector) do |scope|
scope.clicks_link(link_text)
# click_link_within "#user_12", "Vote"
def click_link_within(selector, link_text)
within(selector) do
click_link(link_text)
end
end
alias_method :click_link_within, :clicks_link_within
alias_method :clicks_link_within, :click_link_within
def within(selector)
yield Scope.new(self, response_body, selector)
scopes.push(Scope.from_scope(self, current_scope, selector))
ret = yield(current_scope)
scopes.pop
return ret
end
# Issues a GET request for a page, follows any redirects, and verifies the final page
# load was successful.
#
# Example:
# visits "/"
def visits(url = nil, http_method = :get, data = {})
# visit "/"
def visit(url = nil, http_method = :get, data = {})
request_page(url, http_method, data)
end
alias_method :visit, :visits
alias_method :visits, :visit
def open_in_browser(path) # :nodoc
def open_in_browser(path) #:nodoc
`open #{path}`
end
def rewrite_css_and_image_references(response_html) # :nodoc
def rewrite_css_and_image_references(response_html) #:nodoc
return response_html unless doc_root
response_html.gsub(/"\/(stylesheets|images)/, doc_root + '/\1')
end
# Subclasses can override this to show error messages without html
def formatted_error
def formatted_error #:nodoc:
response_body
end
def scopes #:nodoc:
@_scopes ||= []
end
def page_scope #:nodoc:
@_page_scope ||= Scope.from_page(self, response, response_body)
end
def_delegators :current_scope, :fill_in, :fills_in
def_delegators :current_scope, :check, :checks
@ -166,10 +182,6 @@ module Webrat
def_delegators :current_scope, :attach_file, :attaches_file
def_delegators :current_scope, :click_area, :clicks_area
def_delegators :current_scope, :click_link, :clicks_link
def_delegators :current_scope, :click_get_link, :clicks_get_link
def_delegators :current_scope, :click_delete_link, :clicks_delete_link
def_delegators :current_scope, :click_post_link, :clicks_post_link
def_delegators :current_scope, :click_put_link, :clicks_put_link
def_delegators :current_scope, :click_button, :clicks_button
def_delegators :current_scope, :should_see
def_delegators :current_scope, :should_not_see

2
lib/webrat/core_extensions/blank.rb
View File

@ -1,4 +1,4 @@
class Object
class Object #:nodoc:
# An object is blank if it's false, empty, or a whitespace string.
# For example, "", " ", +nil+, [], and {} are blank.
#

8
lib/webrat/core_extensions/deprecate.rb Normal file
View File

@ -0,0 +1,8 @@
class Module #:nodoc:
def deprecate(old_method_name, new_method_name)
define_method old_method_name do |*args|
warn "#{old_method_name} is deprecated. Use #{new_method_name} instead."
__send__(new_method_name, *args)
end
end
end

12
lib/webrat/core_extensions/detect_mapped.rb Normal file
View File

@ -0,0 +1,12 @@
class Array #:nodoc:
def detect_mapped
each do |element|
result = yield element
return result if result
end
return nil
end
end

4
lib/webrat/core_extensions/hash_with_indifferent_access.rb
View File

@ -1,7 +1,7 @@
# This class has dubious semantics and we only have it so that
# people can write params[:key] instead of params['key']
# and they get the same value for both keys.
class HashWithIndifferentAccess < Hash
class HashWithIndifferentAccess < Hash #:nodoc:
def initialize(constructor = {})
if constructor.is_a?(Hash)
super()
@ -122,7 +122,7 @@ class HashWithIndifferentAccess < Hash
end
end
class Hash
class Hash #:nodoc:
def with_indifferent_access
hash = HashWithIndifferentAccess.new(self)
hash.default = self.default

6
lib/webrat/core_extensions/meta_class.rb Normal file
View File

@ -0,0 +1,6 @@
class ::Object #:nodoc:
def meta_class
class << self; self end
end
end

2
lib/webrat/core_extensions/nil_to_param.rb
View File

@ -1,4 +1,4 @@
class NilClass
class NilClass #:nodoc:
def to_param
nil
end

40
lib/webrat/mechanize.rb
View File

@ -1,3 +1,41 @@
require "mechanize"
require "webrat/mechanize/mechanize_session"
module Webrat
class MechanizeSession < Session
def initialize(mechanize = WWW::Mechanize.new)
super()
@mechanize = mechanize
end
def page
@mechanize_page
end
def get(url, data, headers_argument_not_used = nil)
@mechanize_page = @mechanize.get(url, data)
end
def post(url, data, headers_argument_not_used = nil)
post_data = data.inject({}) do |memo, param|
case param.last
when Hash
param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
else
memo[param.first] = param.last
end
memo
end
@mechanize_page = @mechanize.post(url, post_data)
end
def response_body
@mechanize_page.content
end
def response_code
@mechanize_page.code.to_i
end
end
end

39
lib/webrat/mechanize/mechanize_session.rb
View File

@ -1,39 +0,0 @@
module Webrat
class MechanizeSession < Session
def initialize(mechanize = WWW::Mechanize.new)
super()
@mechanize = mechanize
end
def page
@mechanize_page
end
def get(url, data, headers_argument_not_used = nil)
@mechanize_page = @mechanize.get(url, data)
end
def post(url, data, headers_argument_not_used = nil)
post_data = data.inject({}) do |memo, param|
case param.last
when Hash
param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
else
memo[param.first] = param.last
end
memo
end
@mechanize_page = @mechanize.post(url, post_data)
end
def response_body
@mechanize_page.content
end
def response_code
@mechanize_page.code.to_i
end
end
end

45
lib/webrat/merb.rb
View File

@ -1,10 +1,17 @@
require "webrat/core"
require "cgi"
gem "extlib"
require "extlib"
require "merb-core"
HashWithIndifferentAccess = Mash
module Webrat
class Session
include Merb::Test::RequestHelper
class MerbSession < Session #:nodoc:
include Merb::Test::MakeRequest
attr_reader :response
attr_accessor :response
def get(url, data, headers = nil)
do_request(url, data, headers, "GET")
@ -29,20 +36,40 @@ module Webrat
def response_code
@response.status
end
protected
def do_request(url, data, headers, method)
@response = request(url, :params => (data && data.any?) ? data : nil, :headers => headers, :method => method)
@response = request(url,
:params => (data && data.any?) ? data : nil,
:headers => headers,
:method => method)
follow_redirect
end
def follow_redirect
self.get(@response.headers['Location'], nil, @response.headers) if @response.status == 302
end
end
end
class Merb::Test::RspecStory
def browser
@browser ||= Webrat::Session.new
module Merb
module Test
module RequestHelper #:nodoc:
def request(uri, env = {})
@_webrat_session ||= Webrat::MerbSession.new
@_webrat_session.response = @_webrat_session.request(uri, env)
end
def follow_redirect
@_webrat_session.follow_redirect
end
end
end
end
class Merb::Test::RspecStory #:nodoc:
def browser
@browser ||= Webrat::MerbSession.new
end
end

4
lib/webrat/rack/rack_session.rb → lib/webrat/rack.rb
View File

@ -1,6 +1,6 @@
require 'webrat'
class CGIMethods
class CGIMethods #:nodoc:
def self.parse_query_parameters(params)
hash = {}
params.split('&').each do |p|
@ -12,7 +12,7 @@ class CGIMethods
end
module Webrat
class RackSession < Session
class RackSession < Session #:nodoc:
def response_body
@response.body
end

106
lib/webrat/rails.rb
View File

@ -1,4 +1,102 @@
require "webrat/core"
require "webrat/rails/redirect_actions"
require "webrat/rails/rails_session"
require "webrat/rails/session"
require "webrat"
module Webrat
class RailsSession < Session #:nodoc:
def initialize(integration_session)
super()
@integration_session = integration_session
end
def doc_root
File.expand_path(File.join(RAILS_ROOT, 'public'))
end
def saved_page_dir
File.expand_path(File.join(RAILS_ROOT, "tmp"))
end
def get(url, data, headers = nil)
do_request(:get, url, data, headers)
end
def post(url, data, headers = nil)
do_request(:post, url, data, headers)
end
def put(url, data, headers = nil)
do_request(:put, url, data, headers)
end
def delete(url, data, headers = nil)
do_request(:delete, url, data, headers)
end
def response_body
response.body
end
def response_code
response.code.to_i
end
protected
def do_request(http_method, url, data, headers) #:nodoc:
update_protocol(url)
@integration_session.request_via_redirect(http_method, remove_protocol(url), data, headers)
end
def remove_protocol(href) #:nodoc:
if href =~ %r{^https?://www.example.com(/.*)}
$LAST_MATCH_INFO.captures.first
else
href
end
end
def update_protocol(href) #:nodoc:
if href =~ /^https:/
@integration_session.https!(true)
elsif href =~ /^http:/
@integration_session.https!(false)
end
end
def response #:nodoc:
@integration_session.response
end
end
end
module ActionController
module Integration
class Session #:nodoc:
unless instance_methods.include?("put_via_redirect")
require "webrat/rails/redirect_actions"
include Webrat::RedirectActions
end
def respond_to?(name)
super || webrat_session.respond_to?(name)
end
def method_missing(name, *args, &block)
if webrat_session.respond_to?(name)
webrat_session.send(name, *args, &block)
else
super
end
end
protected
def webrat_session
@webrat_session ||= Webrat::RailsSession.new(self)
end
end
end
end

68
lib/webrat/rails/rails_session.rb
View File

@ -1,68 +0,0 @@
module Webrat
class RailsSession < Session
def initialize(integration_session)
super()
@integration_session = integration_session
end
def doc_root
File.expand_path(File.join(RAILS_ROOT, 'public'))
end
def saved_page_dir
File.expand_path(File.join(RAILS_ROOT, "tmp"))
end
def get(url, data, headers = nil)
update_protocol(url)
@integration_session.get_via_redirect(remove_protocol(url), data, headers)
end
def post(url, data, headers = nil)
update_protocol(url)
@integration_session.post_via_redirect(remove_protocol(url), data, headers)
end
def put(url, data, headers = nil)
update_protocol(url)
@integration_session.put_via_redirect(remove_protocol(url), data, headers)
end
def delete(url, data, headers = nil)
update_protocol(url)
@integration_session.delete_via_redirect(remove_protocol(url), data, headers)
end
def response_body
response.body
end
def response_code
response.code.to_i
end
protected
def remove_protocol(href)
if href =~ %r{^https?://www.example.com(/.*)}
$LAST_MATCH_INFO.captures.first
else
href
end
end
def update_protocol(href)
if href =~ /^https:/
@integration_session.https!(true)
elsif href =~ /^http:/
@integration_session.https!(false)
end
end
def response
@integration_session.response
end
end
end

2
lib/webrat/rails/redirect_actions.rb
View File

@ -1,6 +1,6 @@
# For Rails before http://dev.rubyonrails.org/ticket/10497 was committed
module Webrat
module RedirectActions
module RedirectActions #:nodoc:
def put_via_redirect(path, parameters = {}, headers = {})
put path, parameters, headers

29
lib/webrat/rails/session.rb
View File

@ -1,29 +0,0 @@
module ActionController
module Integration
class Session
unless instance_methods.include?("put_via_redirect")
include Webrat::RedirectActions
end
def respond_to?(name)
super || webrat_session.respond_to?(name)
end
def method_missing(name, *args, &block)
if webrat_session.respond_to?(name)
webrat_session.send(name, *args, &block)
else
super
end
end
protected
def webrat_session
@webrat_session ||= Webrat::RailsSession.new(self)
end
end
end
end

2
lib/webrat/selenium/location_strategy_javascript/button.js
View File

@ -6,7 +6,7 @@ return $A(inputs).find(function(candidate){
inputType = candidate.getAttribute('type');
if (inputType == 'submit' || inputType == 'image') {
var buttonText = $F(candidate);
return (PatternMatcher.matches(locator + '*', buttonText));
return (PatternMatcher.matches(locator, buttonText));
}
return false;
});

6
lib/webrat/selenium/selenium_extensions.js Normal file
View File

@ -0,0 +1,6 @@
PatternMatcher.strategies['evalregex'] = function(regexpString) {
this.regexp = eval(regexpString);
this.matches = function(actual) {
return this.regexp.test(actual);
};
};

77
lib/webrat/selenium/selenium_session.rb
View File

@ -1,45 +1,56 @@
module Webrat
class SeleniumSession < Session
class SeleniumSession
def initialize(selenium_driver)
super()
def initialize(selenium_driver) #:nodoc:
@selenium = selenium_driver
extend_selenium
define_location_strategies
end
def visits(url)
def visit(url)
@selenium.open(url)
end
alias_method :visit, :visits
alias_method :visits, :visit
def fills_in(field_identifier, options)
def fill_in(field_identifier, options)
locator = "webrat=#{Regexp.escape(field_identifier)}"
@selenium.type(locator, "#{options[:with]}")
end
def response_body
alias_method :fills_in, :fill_in
def response_body #:nodoc:
@selenium.get_html_source
end
def clicks_button(button_text = nil, options = {})
button_text, options = nil, button_text if button_text.is_a?(Hash) && options == {}
button_text ||= '*'
@selenium.click("button=#{button_text}")
def click_button(button_text_or_regexp = nil, options = {})
if button_text_or_regexp.is_a?(Hash) && options == {}
pattern, options = nil, button_text_or_regexp
else
pattern = adjust_if_regexp(button_text_or_regexp)
end
pattern ||= '*'
@selenium.click("button=#{pattern}")
wait_for_result(options[:wait])
end
alias_method :click_button, :clicks_button
def clicks_link(link_text, options = {})
@selenium.click("webratlink=#{link_text}")
wait_for_result(options[:wait])
end
alias_method :click_link, :clicks_link
def clicks_link_within(selector, link_text, options = {})
alias_method :clicks_button, :click_button
def click_link(link_text_or_regexp, options = {})
pattern = adjust_if_regexp(link_text_or_regexp)
@selenium.click("webratlink=#{pattern}")
wait_for_result(options[:wait])
end
alias_method :clicks_link, :click_link
def click_link_within(selector, link_text, options = {})
@selenium.click("webratlinkwithin=#{selector}|#{link_text}")
wait_for_result(options[:wait])
end
alias_method :clicks_link_within, :click_link_within
def wait_for_result(wait_type)
if wait_type == :ajax
@ -79,25 +90,43 @@ module Webrat
@selenium.select(select_locator, option_text)
end
def chooses(label_text)
def choose(label_text)
@selenium.click("webrat=#{label_text}")
end
alias_method :chooses, :choose
def checks(label_text)
def check(label_text)
@selenium.check("webrat=#{label_text}")
end
def is_ordered(*args)
alias_method :checks, :check
def is_ordered(*args) #:nodoc:
@selenium.is_ordered(*args)
end
def dragdrop(*args)
def dragdrop(*args) #:nodoc:
@selenium.dragdrop(*args)
end
protected
def define_location_strategies
def adjust_if_regexp(text_or_regexp) #:nodoc:
if text_or_regexp.is_a?(Regexp)
"evalregex:#{text_or_regexp.inspect}"
else
text_or_regexp
end
end
def extend_selenium #:nodoc:
extensions_file = File.join(File.dirname(__FILE__), "selenium_extensions.js")
extenions_js = File.read(extensions_file)
@selenium.get_eval(extenions_js)
end
def define_location_strategies #:nodoc:
Dir[File.join(File.dirname(__FILE__), "location_strategy_javascript", "*.js")].sort.each do |file|
strategy_js = File.read(file)
strategy_name = File.basename(file, '.js')

4
lib/webrat/sinatra/sinatra_session.rb → lib/webrat/sinatra.rb
View File

@ -1,9 +1,9 @@
require 'webrat/rack/rack_session'
require 'webrat/rack'
require 'sinatra'
require 'sinatra/test/methods'
module Webrat
class SinatraSession < RackSession
class SinatraSession < RackSession #:nodoc:
include Sinatra::Test::Methods
%w(get head post put delete).each do |verb|

6
spec/api/basic_auth_spec.rb
View File

@ -6,9 +6,9 @@ describe "Basic Auth HTTP headers" do
@session.basic_auth('user', 'secret')
end
it "should be present in visits" do
it "should be present in visit" do
@session.should_receive(:get).with("/", {}, {'HTTP_AUTHORIZATION' => "Basic dXNlcjpzZWNyZXQ=\n"})
@session.visits("/")
@session.visit("/")
end
it "should be present in form submits" do
@ -18,6 +18,6 @@ describe "Basic Auth HTTP headers" do
</form>
EOS
@session.should_receive(:post).with("/form1", {}, {'HTTP_AUTHORIZATION' => "Basic dXNlcjpzZWNyZXQ=\n"})
@session.clicks_button
@session.click_button
end
end

38
spec/api/checks_spec.rb → spec/api/check_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "checks" do
describe "check" do
before do
@session = Webrat::TestSession.new
end
@ -11,7 +11,7 @@ describe "checks" do
</form>
EOS
lambda { @session.checks "remember_me" }.should raise_error
lambda { @session.check "remember_me" }.should raise_error
end
it "should fail if input is not a checkbox" do
@ -21,7 +21,7 @@ describe "checks" do
</form>
EOS
lambda { @session.checks "remember_me" }.should raise_error
lambda { @session.check "remember_me" }.should raise_error
end
it "should check rails style checkboxes" do
@ -34,8 +34,8 @@ describe "checks" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"tos" => "1"})
@session.checks "TOS"
@session.clicks_button
@session.check "TOS"
@session.click_button
end
it "should result in the value on being posted if not specified" do
@ -46,8 +46,8 @@ describe "checks" do
</form>
EOS
@session.should_receive(:post).with("/login", "remember_me" => "on")
@session.checks "remember_me"
@session.clicks_button
@session.check "remember_me"
@session.click_button
end
it "should fail if the checkbox is disabled" do
@ -57,7 +57,7 @@ describe "checks" do
<input type="submit" />
</form>
EOS
lambda { @session.checks "remember_me" }.should raise_error
lambda { @session.check "remember_me" }.should raise_error
end
it "should result in a custom value being posted" do
@ -68,12 +68,12 @@ describe "checks" do
</form>
EOS
@session.should_receive(:post).with("/login", "remember_me" => "yes")
@session.checks "remember_me"
@session.clicks_button
@session.check "remember_me"
@session.click_button
end
end
describe "unchecks" do
describe "uncheck" do
before do
@session = Webrat::TestSession.new
end
@ -84,7 +84,7 @@ describe "unchecks" do
</form>
EOS
lambda { @session.unchecks "remember_me" }.should raise_error
lambda { @session.uncheck "remember_me" }.should raise_error
end
it "should fail if input is not a checkbox" do
@ -94,7 +94,7 @@ describe "unchecks" do
</form>
EOS
lambda { @session.unchecks "remember_me" }.should raise_error
lambda { @session.uncheck "remember_me" }.should raise_error
end
it "should fail if the checkbox is disabled" do
@ -104,7 +104,7 @@ describe "unchecks" do
<input type="submit" />
</form>
EOS
lambda { @session.unchecks "remember_me" }.should raise_error
lambda { @session.uncheck "remember_me" }.should raise_error
end
it "should uncheck rails style checkboxes" do
@ -117,9 +117,9 @@ describe "unchecks" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"tos" => "0"})
@session.checks "TOS"
@session.unchecks "TOS"
@session.clicks_button
@session.check "TOS"
@session.uncheck "TOS"
@session.click_button
end
it "should result in value not being posted" do
@ -130,7 +130,7 @@ describe "unchecks" do
</form>
EOS
@session.should_receive(:post).with("/login", {})
@session.unchecks "remember_me"
@session.clicks_button
@session.uncheck "remember_me"
@session.click_button
end
end

28
spec/api/chooses_spec.rb → spec/api/choose_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "chooses" do
describe "choose" do
before do
@session = Webrat::TestSession.new
end
@ -11,7 +11,7 @@ describe "chooses" do
</form>
EOS
lambda { @session.chooses "first option" }.should raise_error
lambda { @session.choose "first option" }.should raise_error
end
it "should fail if input is not a radio button" do
@ -21,7 +21,7 @@ describe "chooses" do
</form>
EOS
lambda { @session.chooses "first_option" }.should raise_error
lambda { @session.choose "first_option" }.should raise_error
end
it "should check rails style radio buttons" do
@ -35,8 +35,8 @@ describe "chooses" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"gender" => "M"})
@session.chooses "Male"
@session.clicks_button
@session.choose "Male"
@session.click_button
end
it "should only submit last chosen value" do
@ -50,9 +50,9 @@ describe "chooses" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"gender" => "M"})
@session.chooses "Female"
@session.chooses "Male"
@session.clicks_button
@session.choose "Female"
@session.choose "Male"
@session.click_button
end
it "should fail if the radio button is disabled" do
@ -63,7 +63,7 @@ describe "chooses" do
</form>
EOS
lambda { @session.chooses "first_option" }.should raise_error
lambda { @session.choose "first_option" }.should raise_error
end
it "should result in the value on being posted if not specified" do
@ -74,8 +74,8 @@ describe "chooses" do
</form>
EOS
@session.should_receive(:post).with("/login", "first_option" => "on")
@session.chooses "first_option"
@session.clicks_button
@session.choose "first_option"
@session.click_button
end
it "should result in the value on being posted if not specified and checked by default" do
@ -86,7 +86,7 @@ describe "chooses" do
</form>
EOS
@session.should_receive(:post).with("/login", "first_option" => "on")
@session.clicks_button
@session.click_button
end
it "should result in the value of the selected radio button being posted when a subsequent one is checked by default" do
@ -100,7 +100,7 @@ describe "chooses" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"gender" => "M"})
@session.chooses "Male"
@session.clicks_button
@session.choose "Male"
@session.click_button
end
end

18
spec/api/clicks_area_spec.rb → spec/api/click_area_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "clicks_area" do
describe "click_area" do
before do
@session = Webrat::TestSession.new
end
@ -12,7 +12,7 @@ describe "clicks_area" do
</map>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_area "Berlin"
@session.click_area "Berlin"
end
it "should assert valid response" do
@ -22,7 +22,7 @@ describe "clicks_area" do
</map>
EOS
@session.response_code = 501
lambda { @session.clicks_area "Berlin" }.should raise_error
lambda { @session.click_area "Berlin" }.should raise_error
end
[200, 300, 400, 499].each do |status|
@ -33,7 +33,7 @@ describe "clicks_area" do
</map>
EOS
@session.response_code = status
lambda { @session.clicks_area "Berlin" }.should_not raise_error
lambda { @session.click_area "Berlin" }.should_not raise_error
end
end
@ -45,7 +45,7 @@ describe "clicks_area" do
EOS
lambda {
@session.clicks_area "Missing area"
@session.click_area "Missing area"
}.should raise_error
end
@ -56,7 +56,7 @@ describe "clicks_area" do
</map>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_area "berlin"
@session.click_area "berlin"
end
@ -68,7 +68,7 @@ describe "clicks_area" do
</map>
EOS
@session.should_receive(:get).with("/page/sub", {})
@session.clicks_area "Berlin"
@session.click_area "Berlin"
end
it "should follow fully qualified local links" do
@ -78,7 +78,7 @@ describe "clicks_area" do
</map>
EOS
@session.should_receive(:get).with("http://www.example.com/page", {})
@session.clicks_area "Berlin"
@session.click_area "Berlin"
end
it "should follow query parameters" do
@ -88,6 +88,6 @@ describe "clicks_area" do
</map>
EOS
@session.should_receive(:get).with("/page?foo=bar", {})
@session.clicks_area "Berlin"
@session.click_area "Berlin"
end
end

70
spec/api/clicks_button_spec.rb → spec/api/click_button_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "clicks_button" do
describe "click_button" do
before do
@session = Webrat::TestSession.new
end
@ -10,7 +10,7 @@ describe "clicks_button" do
<form method="get" action="/login"></form>
EOS
lambda { @session.clicks_button }.should raise_error
lambda { @session.click_button }.should raise_error
end
it "should fail if input is not a submit button" do
@ -20,7 +20,7 @@ describe "clicks_button" do
</form>
EOS
lambda { @session.clicks_button }.should raise_error
lambda { @session.click_button }.should raise_error
end
@ -31,7 +31,7 @@ describe "clicks_button" do
</form>
EOS
lambda { @session.clicks_button }.should raise_error
lambda { @session.click_button }.should raise_error
end
it "should default to get method" do
@ -41,7 +41,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get)
@session.clicks_button
@session.click_button
end
it "should assert valid response" do
@ -51,7 +51,7 @@ describe "clicks_button" do
</form>
EOS
@session.response_code = 501
lambda { @session.clicks_button }.should raise_error
lambda { @session.click_button }.should raise_error
end
[200, 300, 400, 499].each do |status|
@ -62,7 +62,7 @@ describe "clicks_button" do
</form>
EOS
@session.response_code = status
lambda { @session.clicks_button }.should_not raise_error
lambda { @session.click_button }.should_not raise_error
end
end
@ -76,7 +76,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/form1", {})
@session.clicks_button
@session.click_button
end
it "should not explode on file fields" do
@ -86,7 +86,7 @@ describe "clicks_button" do
<input type="submit" />
</form>
EOS
@session.clicks_button
@session.click_button
end
it "should submit the form with the specified button" do
@ -99,7 +99,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/form2", {})
@session.clicks_button "Form2"
@session.click_button "Form2"
end
it "should use action from form" do
@ -109,7 +109,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", {})
@session.clicks_button
@session.click_button
end
it "should use method from form" do
@ -119,7 +119,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:post)
@session.clicks_button
@session.click_button
end
it "should send button as param if it has a name" do
@ -130,7 +130,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:post).with("/login", "login" => "Login")
@session.clicks_button("Login")
@session.click_button("Login")
end
it "should not send button as param if it has no name" do
@ -141,7 +141,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:post).with("/login", {})
@session.clicks_button("Login")
@session.click_button("Login")
end
it "should send default password field values" do
@ -152,7 +152,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"password" => "mypass"})
@session.clicks_button
@session.click_button
end
it "should send default hidden field values" do
@ -163,7 +163,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"email" => "test@example.com"})
@session.clicks_button
@session.click_button
end
it "should send default text field values" do
@ -174,7 +174,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"email" => "test@example.com"})
@session.clicks_button
@session.click_button
end
it "should not send disabled field values" do
@ -189,7 +189,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", {})
@session.clicks_button
@session.click_button
end
it "should send default checked fields" do
@ -200,7 +200,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"tos" => "1"})
@session.clicks_button
@session.click_button
end
it "should send default radio options" do
@ -214,7 +214,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"gender" => "F"})
@session.clicks_button
@session.click_button
end
it "should send correct data for rails style unchecked fields" do
@ -226,7 +226,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"tos" => "0"})
@session.clicks_button
@session.click_button
end
it "should send correct data for rails style checked fields" do
@ -238,7 +238,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"tos" => "1"})
@session.clicks_button
@session.click_button
end
it "should send default collection fields" do
@ -260,7 +260,7 @@ describe "clicks_button" do
@session.should_receive(:post).with("/login",
"options" => ["burger", "fries", "soda", "soda", "dessert"],
"response" => { "choices" => [{"selected" => "one"}, {"selected" => "two"}, {"selected" => "two"}]})
@session.clicks_button
@session.click_button
end
it "should not send default unchecked fields" do
@ -271,7 +271,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", {})
@session.clicks_button
@session.click_button
end
it "should send default textarea values" do
@ -282,7 +282,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:post).with("/posts", "post" => {"body" => "Post body here!"})
@session.clicks_button
@session.click_button
end
it "should send default selected option value from select" do
@ -296,7 +296,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "month" => "2")
@session.clicks_button
@session.click_button
end
it "should send default selected option inner html from select when no value attribute" do
@ -310,7 +310,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "month" => "February")
@session.clicks_button
@session.click_button
end
it "should send first select option value when no option selected" do
@ -324,7 +324,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "month" => "1")
@session.clicks_button
@session.click_button
end
it "should handle nested properties" do
@ -336,7 +336,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:post).with("/login", "contestant" => {"scores" => {'1' => '2', '3' => '4'}})
@session.clicks_button
@session.click_button
end
it "should send default empty text field values" do
@ -347,7 +347,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"email" => ""})
@session.clicks_button
@session.click_button
end
it "should recognize button tags" do
@ -358,7 +358,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"email" => ""})
@session.clicks_button
@session.click_button
end
it "should recognize image button tags" do
@ -368,7 +368,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get)
@session.clicks_button
@session.click_button
end
it "should find buttons by their IDs" do
@ -378,7 +378,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get)
@session.clicks_button "my_button"
@session.click_button "my_button"
end
it "should find image buttons by their alt text" do
@ -388,7 +388,7 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get)
@session.clicks_button "Go"
@session.click_button "Go"
end
it "should recognize button tags by content" do
@ -399,6 +399,6 @@ describe "clicks_button" do
</form>
EOS
@session.should_receive(:get).with("/login", "user" => {"email" => ""})
@session.clicks_button "Login"
@session.click_button "Login"
end
end

60
spec/api/clicks_link_spec.rb → spec/api/click_link_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "clicks_link" do
describe "click_link" do
before do
@session = Webrat::TestSession.new
end
@ -10,7 +10,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_link "Link text"
@session.click_link "Link text"
end
it "should click get links" do
@ -18,7 +18,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_link "Link text", :method => :get
@session.click_link "Link text", :method => :get
end
it "should click delete links" do
@ -26,7 +26,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:delete).with("/page", {})
@session.clicks_link "Link text", :method => :delete
@session.click_link "Link text", :method => :delete
end
@ -35,7 +35,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:post).with("/page", {})
@session.clicks_link "Link text", :method => :post
@session.click_link "Link text", :method => :post
end
it "should click put links" do
@ -43,7 +43,15 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:put).with("/page", {})
@session.clicks_link "Link text", :method => :put
@session.click_link "Link text", :method => :put
end
it "should click links by regexp" do
@session.response_body = <<-EOS
<a href="/page">Link text</a>
EOS
@session.should_receive(:get).with("/page", {})
@session.click_link /link [a-z]/i
end
it "should click rails javascript links with authenticity tokens" do
@ -62,7 +70,7 @@ describe "clicks_link" do
return false;">Posts</a>
EOS
@session.should_receive(:post).with("/posts", "authenticity_token" => "aa79cb354597a60a3786e7e291ed4f74d77d3a62")
@session.clicks_link "Posts"
@session.click_link "Posts"
end
it "should click rails javascript delete links" do
@ -81,7 +89,7 @@ describe "clicks_link" do
return false;">Delete</a>
EOS
@session.should_receive(:delete).with("/posts/1", {})
@session.clicks_link "Delete"
@session.click_link "Delete"
end
it "should click rails javascript post links" do
@ -95,7 +103,7 @@ describe "clicks_link" do
return false;">Posts</a>
EOS
@session.should_receive(:post).with("/posts", {})
@session.clicks_link "Posts"
@session.click_link "Posts"
end
it "should click rails javascript post links without javascript" do
@ -109,7 +117,7 @@ describe "clicks_link" do
return false;">Posts</a>
EOS
@session.should_receive(:get).with("/posts", {})
@session.clicks_link "Posts", :javascript => false
@session.click_link "Posts", :javascript => false
end
it "should click rails javascript put links" do
@ -128,7 +136,7 @@ describe "clicks_link" do
return false;">Put</a></h2>
EOS
@session.should_receive(:put).with("/posts", {})
@session.clicks_link "Put"
@session.click_link "Put"
end
it "should fail if the javascript link doesn't have a value for the _method input" do
@ -147,7 +155,7 @@ describe "clicks_link" do
EOS
lambda {
@session.clicks_link "Link"
@session.click_link "Link"
}.should raise_error
end
@ -156,7 +164,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.response_code = 501
lambda { @session.clicks_link "Link text" }.should raise_error
lambda { @session.click_link "Link text" }.should raise_error
end
[200, 300, 400, 499].each do |status|
@ -165,7 +173,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.response_code = status
lambda { @session.clicks_link "Link text" }.should_not raise_error
lambda { @session.click_link "Link text" }.should_not raise_error
end
end
@ -175,7 +183,7 @@ describe "clicks_link" do
EOS
lambda {
@session.clicks_link "Missing link"
@session.click_link "Missing link"
}.should raise_error
end
@ -184,7 +192,7 @@ describe "clicks_link" do
<a href="/page">Link text</a>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_link "LINK TEXT"
@session.click_link "LINK TEXT"
end
it "should match link substrings" do
@ -192,7 +200,7 @@ describe "clicks_link" do
<a href="/page">This is some cool link text, isn't it?</a>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_link "Link text"
@session.click_link "Link text"
end
it "should work with elements in the link" do
@ -200,7 +208,7 @@ describe "clicks_link" do
<a href="/page"><span>Link text</span></a>
EOS
@session.should_receive(:get).with("/page", {})
@session.clicks_link "Link text"
@session.click_link "Link text"
end
it "should match the first matching link" do
@ -209,7 +217,7 @@ describe "clicks_link" do
<a href="/page2">Link text</a>
EOS
@session.should_receive(:get).with("/page1", {})
@session.clicks_link "Link text"
@session.click_link "Link text"
end
it "should choose the shortest link text match" do
@ -219,7 +227,7 @@ describe "clicks_link" do
EOS
@session.should_receive(:get).with("/page2", {})
@session.clicks_link "Link"
@session.click_link "Link"
end
it "should treat non-breaking spaces as spaces" do
@ -228,7 +236,7 @@ describe "clicks_link" do
EOS
@session.should_receive(:get).with("/page1", {})
@session.clicks_link "This is a link"
@session.click_link "This is a link"
end
it "should click link within a selector" do
@ -240,7 +248,7 @@ describe "clicks_link" do
EOS
@session.should_receive(:get).with("/page2", {})
@session.clicks_link_within "#container", "Link"
@session.click_link_within "#container", "Link"
end
it "should not make request when link is local anchor" do
@ -249,7 +257,7 @@ describe "clicks_link" do
EOS
# Don't know why @session.should_receive(:get).never doesn't work here
@session.should_receive(:send).with('get_via_redirect', '#section-1', {}).never
@session.clicks_link "Jump to Section 1"
@session.click_link "Jump to Section 1"
end
it "should follow relative links" do
@ -258,7 +266,7 @@ describe "clicks_link" do
<a href="sub">Jump to sub page</a>
EOS
@session.should_receive(:get).with("/page/sub", {})
@session.clicks_link "Jump to sub page"
@session.click_link "Jump to sub page"
end
it "should follow fully qualified local links" do
@ -266,7 +274,7 @@ describe "clicks_link" do
<a href="http://www.example.com/page/sub">Jump to sub page</a>
EOS
@session.should_receive(:get).with("http://www.example.com/page/sub", {})
@session.clicks_link "Jump to sub page"
@session.click_link "Jump to sub page"
end
it "should follow query parameters" do
@ -275,6 +283,6 @@ describe "clicks_link" do
<a href="?foo=bar">Jump to foo bar</a>
EOS
@session.should_receive(:get).with("/page?foo=bar", {})
@session.clicks_link "Jump to foo bar"
@session.click_link "Jump to foo bar"
end
end

22
spec/api/element_labeled_spec.rb → spec/api/field_labeled_spec.rb
View File

@ -44,25 +44,25 @@ describe "field_labeled" do
end
describe "finding a text field" do
using_this_html <<-EOS
using_this_html <<-HTML
<form>
<label for="element_42">The Label</label>
<input type="text" id="element_42">
</form>
EOS
HTML
should_return_a Webrat::TextField, :for => "The Label"
with_an_id_of "element_42", :for => "The Label"
should_raise_error_matching /Could not find .* "Other Label"/, :for => "Other Label"
end
describe "finding a text field" do
using_this_html <<-EOS
describe "finding a hidden field" do
using_this_html <<-HTML
<form>
<label for="element_42">The Label</label>
<input type="hidden" id="element_42">
</form>
EOS
HTML
should_return_a Webrat::HiddenField, :for => "The Label"
with_an_id_of "element_42", :for => "The Label"
@ -70,12 +70,12 @@ describe "field_labeled" do
end
describe "finding a checkbox" do
using_this_html <<-EOS
using_this_html <<-HTML
<form>
<label for="element_42">The Label</label>
<input type="checkbox" id="element_42">
</form>
EOS
HTML
should_return_a Webrat::CheckboxField, :for => "The Label"
with_an_id_of "element_42", :for => "The Label"
@ -83,12 +83,12 @@ describe "field_labeled" do
end
describe "finding a radio button" do
using_this_html <<-EOS
using_this_html <<-HTML
<form>
<label for="element_42">The Label</label>
<input type="radio" id="element_42">
</form>
EOS
HTML
should_return_a Webrat::RadioField, :for => "The Label"
with_an_id_of "element_42", :for => "The Label"
@ -97,12 +97,12 @@ describe "field_labeled" do
describe "finding a text area" do
using_this_html <<-EOS
using_this_html <<-HTML
<form>
<label for="element_42">The Label</label>
<textarea id="element_42"></textarea>
</form>
EOS
HTML
should_return_a Webrat::TextareaField, :for => "The Label"
with_an_id_of "element_42", :for => "The Label"

50
spec/api/fills_in_spec.rb → spec/api/fill_in_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "fills_in" do
describe "fill_in" do
before do
@session = Webrat::TestSession.new
end
@ -14,8 +14,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"text" => "filling text area"})
@session.fills_in "User Text", :with => "filling text area"
@session.clicks_button
@session.fill_in "User Text", :with => "filling text area"
@session.click_button
end
it "should work with password fields" do
@ -26,8 +26,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"text" => "pass"})
@session.fills_in "user_text", :with => "pass"
@session.clicks_button
@session.fill_in "user_text", :with => "pass"
@session.click_button
end
it "should fail if input not found" do
@ -36,7 +36,7 @@ describe "fills_in" do
</form>
EOS
lambda { @session.fills_in "Email", :with => "foo@example.com" }.should raise_error
lambda { @session.fill_in "Email", :with => "foo@example.com" }.should raise_error
end
it "should fail if input is disabled" do
@ -48,7 +48,7 @@ describe "fills_in" do
</form>
EOS
lambda { @session.fills_in "Email", :with => "foo@example.com" }.should raise_error
lambda { @session.fill_in "Email", :with => "foo@example.com" }.should raise_error
end
it "should allow overriding default form values" do
@ -60,8 +60,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"email" => "foo@example.com"})
@session.fills_in "user[email]", :with => "foo@example.com"
@session.clicks_button
@session.fill_in "user[email]", :with => "foo@example.com"
@session.click_button
end
it "should choose the shortest label match" do
@ -76,8 +76,8 @@ describe "fills_in" do
EOS
@session.should_receive(:post).with("/login", "user" => {"mail1" => "", "mail2" => "value"})
@session.fills_in "Some", :with => "value"
@session.clicks_button
@session.fill_in "Some", :with => "value"
@session.click_button
end
it "should choose the first label match if closest is a tie" do
@ -92,8 +92,8 @@ describe "fills_in" do
EOS
@session.should_receive(:post).with("/login", "user" => {"mail1" => "value", "mail2" => ""})
@session.fills_in "Some mail", :with => "value"
@session.clicks_button
@session.fill_in "Some mail", :with => "value"
@session.click_button
end
it "should anchor label matches to start of label" do
@ -104,7 +104,7 @@ describe "fills_in" do
</form>
EOS
lambda { @session.fills_in "mail", :with => "value" }.should raise_error
lambda { @session.fill_in "mail", :with => "value" }.should raise_error
end
it "should anchor label matches to word boundaries" do
@ -115,7 +115,7 @@ describe "fills_in" do
</form>
EOS
lambda { @session.fills_in "Email", :with => "value" }.should raise_error
lambda { @session.fill_in "Email", :with => "value" }.should raise_error
end
it "should work with inputs nested in labels" do
@ -129,8 +129,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"email" => "foo@example.com"})
@session.fills_in "Email", :with => "foo@example.com"
@session.clicks_button
@session.fill_in "Email", :with => "foo@example.com"
@session.click_button
end
it "should work with full input names" do
@ -141,8 +141,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"email" => "foo@example.com"})
@session.fills_in "user[email]", :with => "foo@example.com"
@session.clicks_button
@session.fill_in "user[email]", :with => "foo@example.com"
@session.click_button
end
it "should work if the input type is not set" do
@ -153,8 +153,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"email" => "foo@example.com"})
@session.fills_in "user[email]", :with => "foo@example.com"
@session.clicks_button
@session.fill_in "user[email]", :with => "foo@example.com"
@session.click_button
end
it "should work with symbols" do
@ -166,8 +166,8 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/login", "user" => {"email" => "foo@example.com"})
@session.fills_in :email, :with => "foo@example.com"
@session.clicks_button
@session.fill_in :email, :with => "foo@example.com"
@session.click_button
end
it "should escape field values" do
@ -179,7 +179,7 @@ describe "fills_in" do
</form>
EOS
@session.should_receive(:post).with("/users", "user" => {"phone" => "+1 22 33"})
@session.fills_in 'Phone', :with => "+1 22 33"
@session.clicks_button
@session.fill_in 'Phone', :with => "+1 22 33"
@session.click_button
end
end

178
spec/api/matchers_spec.rb Normal file
View File

@ -0,0 +1,178 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe Webrat::Matchers do
include Webrat::Matchers
include Webrat::HaveTagMatcher
before(:each) do
@body = <<-EOF
<div id='main'>
<div class='inner'>hello, world!</div>
<ul>
<li>First</li>
<li>Second</li>
</ul>
</div>
EOF
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") { |node| node.first.name.should == "div" }
end
it "should not match of any of the matchers in the block fail" do
lambda {
@body.should have_xpath("//div") { |node| node.first.name.should == "p" }
}.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
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") { |node| node.first.name.should == "div" }
end
it "should not match of any of the matchers in the block fail" do
lambda {
@body.should have_selector("div") { |node| node.first.name.should == "p" }
}.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
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") { |node| node.first.name.should == "div" }
end
it "should not match of any of the matchers in the block fail" do
lambda {
@body.should have_tag("div") { |node| node.first.name.should == "p" }
}.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
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 "#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

2
spec/api/reloads_spec.rb → spec/api/reload_spec.rb
View File

@ -9,7 +9,7 @@ describe "reloads" do
it "should reload the page with http referer" do
@session.should_receive(:get).with("/", {})
@session.should_receive(:get).with("/", {}, {"HTTP_REFERER"=>"/"})
@session.visits("/")
@session.visit("/")
@session.reloads
end
end

18
spec/api/selects_spec.rb
View File

@ -57,7 +57,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "month" => "1")
@session.selects "January", :from => "month"
@session.clicks_button
@session.click_button
end
it "should send values with HTML encoded ampersands" do
@ -69,7 +69,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "encoded" => "A & B")
@session.selects "Encoded", :from => "encoded"
@session.clicks_button
@session.click_button
end
it "should work with empty select lists" do
@ -80,7 +80,7 @@ describe "selects" do
</form>
EOS
@session.should_receive(:post).with("/login", 'month' => '')
@session.clicks_button
@session.click_button
end
it "should work without specifying the field name or label" do
@ -92,7 +92,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "month" => "1")
@session.selects "January"
@session.clicks_button
@session.click_button
end
it "should send value from option in list specified by name" do
@ -105,7 +105,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "start_month" => "s1", "end_month" => "e1")
@session.selects "January", :from => "end_month"
@session.clicks_button
@session.click_button
end
it "should send value from option in list specified by label" do
@ -120,7 +120,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "start_month" => "s1", "end_month" => "e1")
@session.selects "January", :from => "End Month"
@session.clicks_button
@session.click_button
end
it "should use option text if no value" do
@ -132,7 +132,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "month" => "January")
@session.selects "January", :from => "month"
@session.clicks_button
@session.click_button
end
it "should find option by regexp" do
@ -144,7 +144,7 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "month" => "January")
@session.selects(/jan/i)
@session.clicks_button
@session.click_button
end
it "should fail if no option matching the regexp exists" do
@ -172,6 +172,6 @@ describe "selects" do
EOS
@session.should_receive(:post).with("/login", "start_month" => "s1", "end_month" => "e1")
@session.selects(/jan/i, :from => "End Month")
@session.clicks_button
@session.click_button
end
end

73
spec/api/should_not_see_spec.rb
View File

@ -1,73 +0,0 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "should_not_see" do
before do
@session = Webrat::TestSession.new
end
it "should fail if the string is in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
lambda {
@session.should_not_see "Link"
}.should raise_error
end
it "should fail if the regexp is in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
lambda {
@session.should_not_see /Li(n)[ck]/
}.should raise_error
end
it "should fail if the string is in the HTML scope" do
@session.response_body = <<-EOS
<div id="first">
<a href="/page2">Link</a>
</div>
<div id="second">
</div>
EOS
lambda {
@session.within "#first" do |scope|
scope.should_not_see "Link"
end
}.should raise_error
end
it "should pass if the string is not in the HTML scope" do
@session.response_body = <<-EOS
<div id="first">
<a href="/page2">Link</a>
</div>
<div id="second">
</div>
EOS
@session.within "#second" do |scope|
scope.should_not_see "Link"
end
end
it "should pass if the string is not in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
@session.should_not_see "Missing"
end
it "should pass if the regexp is not in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Different</a>
EOS
@session.should_not_see /Li(n)[ck]/
end
end

73
spec/api/should_see_spec.rb
View File

@ -1,73 +0,0 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "should_see" do
before do
@session = Webrat::TestSession.new
end
it "should pass if the string is in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
@session.should_see "Link"
end
it "should pass if the regexp is in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
@session.should_see /Li(n)[ck]/
end
it "should pass if the string is in the HTML scope" do
@session.response_body = <<-EOS
<div id="first">
<a href="/page2">Link</a>
</div>
<div id="second">
</div>
EOS
@session.within "#first" do |scope|
scope.should_see "Link"
end
end
it "should fail if the string is not in the HTML scope" do
@session.response_body = <<-EOS
<div id="first">
<a href="/page2">Link</a>
</div>
<div id="second">
</div>
EOS
lambda {
@session.within "#second" do |scope|
scope.should_see "Link"
end
}.should raise_error
end
it "should fail if the string is not in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Link</a>
EOS
lambda {
@session.should_see "Missing"
}.should raise_error
end
it "should fail if the regexp is not in the HTML" do
@session.response_body = <<-EOS
<a href="/page2">Different</a>
EOS
lambda {
@session.should_see /Li(n)[ck]/
}.should raise_error
end
end

14
spec/api/visits_spec.rb → spec/api/visit_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "visits" do
describe "visit" do
before do
@session = Webrat::TestSession.new
@session.response_body = "Hello world"
@ -8,27 +8,27 @@ describe "visits" do
it "should use get" do
@session.should_receive(:get).with("/", {})
@session.visits("/")
@session.visit("/")
end
it "should assert valid response" do
@session.response_code = 501
lambda { @session.visits("/") }.should raise_error
lambda { @session.visit("/") }.should raise_error
end
[200, 300, 400, 499].each do |status|
it "should consider the #{status} status code as success" do
@session.response_code = status
lambda { @session.visits("/") }.should_not raise_error
lambda { @session.visit("/") }.should_not raise_error
end
end
it "should require a visit before manipulating page" do
lambda { @session.fills_in "foo", :with => "blah" }.should raise_error
lambda { @session.fill_in "foo", :with => "blah" }.should raise_error
end
end
describe "visits with referer" do
describe "visit with referer" do
before do
@session = Webrat::TestSession.new
@session.instance_variable_set(:@current_url, "/old_url")
@ -37,7 +37,7 @@ describe "visits with referer" do
it "should use get with referer header" do
@session.should_receive(:get).with("/", {}, {"HTTP_REFERER" => "/old_url"})
@session.visits("/")
@session.visit("/")
end
end

32
spec/api/within_spec.rb
View File

@ -5,6 +5,24 @@ describe "within" do
@session = Webrat::TestSession.new
end
it "should work when nested" do
@session.response_body = <<-EOS
<div>
<a href="/page1">Link</a>
</div>
<div id="container">
<div><a href="/page2">Link</a></div>
</div>
EOS
@session.should_receive(:get).with("/page2", {})
@session.within "#container" do
@session.within "div" do
@session.click_link "Link"
end
end
end
it "should click links within a scope" do
@session.response_body = <<-EOS
<a href="/page1">Link</a>
@ -14,8 +32,8 @@ describe "within" do
EOS
@session.should_receive(:get).with("/page2", {})
@session.within "#container" do |scope|
scope.clicks_link "Link"
@session.within "#container" do
@session.click_link "Link"
end
end
@ -32,9 +50,9 @@ describe "within" do
EOS
@session.should_receive(:get).with("/form2", "email" => "test@example.com")
@session.within "#form2" do |scope|
scope.fill_in "Email", :with => "test@example.com"
scope.clicks_button
@session.within "#form2" do
@session.fill_in "Email", :with => "test@example.com"
@session.click_button
end
end
@ -47,9 +65,9 @@ describe "within" do
</form>
EOS
@session.within "#form2" do |scope|
@session.within "#form2" do
lambda {
scope.clicks_button
@session.click_button
}.should raise_error
end
end

4
spec/fakes/test_session.rb
View File

@ -7,6 +7,10 @@ module Webrat
File.expand_path(File.join(".", "public"))
end
def response
@response ||= Object.new
end
def response_code
@response_code || 200
end

1
spec/spec_helper.rb
View File

@ -1,6 +1,5 @@
require "rubygems"
require "spec"
require "spec/interop/test"
# gem install redgreen for colored test output
begin require "redgreen" unless ENV['TM_CURRENT_LINE']; rescue LoadError; end

4
spec/webrat/core/field_spec.rb
View File

@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
module Webrat
describe CheckboxField do
it "should say it is checked if it is" do
checkbox = CheckboxField.new(nil, (Hpricot("<input type='checkbox' checked='checked'>")/'input').first)
checkbox = CheckboxField.new(nil, (Webrat.nokogiri_document("<input type='checkbox' checked='checked'>")/'input').first)
checkbox.should be_checked
end
it "should say it is not checked if it is not" do
checkbox = CheckboxField.new(nil, (Hpricot("<input type='checkbox'>")/'input').first)
checkbox = CheckboxField.new(nil, (Webrat.nokogiri_document("<input type='checkbox'>")/'input').first)
checkbox.should_not be_checked
end
end

21
spec/webrat/core/session_spec.rb
View File

@ -10,11 +10,15 @@ describe Webrat::Session do
it "should expose the current_dom" do
session = Webrat::Session.new
def session.response
Object.new
end
def session.response_body
"<html></html>"
end
session.current_dom.should be_an_instance_of(Hpricot::Doc)
session.current_dom.should be_an_instance_of(Nokogiri::HTML::Document)
end
it "should open the page in the browser" do
@ -65,5 +69,20 @@ describe Webrat::Session do
lambda { @session.http_accept(:oogabooga) }.should raise_error(ArgumentError)
end
end
describe "#request_page" do
before(:each) do
@session = Webrat::Session.new
end
it "should raise an error if the request is not a success" do
@session.stub!(:get)
@session.stub!(:response_body).and_return("Exception caught")
@session.stub!(:response_code).and_return(500)
@session.stub!(:formatted_error).and_return("application error")
@session.stub!(:save_and_open_page)
lambda { @session.request_page('some url', :get, {}) }.should raise_error(Webrat::PageLoadError)
end
end
end

6
spec/webrat/merb/session_spec.rb
View File

@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + "/helper")
describe Webrat::Session do
it "should not pass empty params if data is and empty hash" do
session = Webrat::Session.new
session = Webrat::MerbSession.new
response = OpenStruct.new
response.status = 200
session.should_receive(:request).with('url', {:params=> nil, :method=>"GET", :headers=>nil}).and_return(response)
@ -13,7 +13,7 @@ describe Webrat::Session do
%w{post put delete}.each do |request_method|
it "should call do request with method #{request_method.upcase} for a #{request_method} call" do
session = Webrat::Session.new
session = Webrat::MerbSession.new
response = OpenStruct.new
response.status = 200
@ -25,7 +25,7 @@ describe Webrat::Session do
context "a session with a response" do
setup do
@session = Webrat::Session.new
@session = Webrat::MerbSession.new
@response = OpenStruct.new
@response.status = 200
@response.body = 'test response'

75
spec/webrat/nokogiri_spec.rb Normal file
View File

@ -0,0 +1,75 @@
require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
describe "Nokogiri Extension" do
include Webrat::Matchers
def fail
raise_error(Spec::Expectations::ExpectationNotMetError)
end
before(:each) do
@text_and_password = <<-HTML
<div>
<input type="text"/>
<input type="password"/>
<span type="text"/>
</div>
HTML
@text_only = <<-HTML
<div>
<input type="text" disabled="disabled" />
</div>
HTML
@password_only = <<-HTML
<div>
<input type="password"/>
<div>
HTML
end
describe ":text" do
it "passes have_selector(:text) if a node with type=text exists" do
@text_and_password.should have_selector(":text")
end
it "passes not have_selector(:text) if no node with text=text exists" do
@password_only.should_not have_selector(":text")
end
it "fails have_selector(:text) if no node with type=text exists" do
lambda { @password_only.should have_selector(":text") }.should fail
end
it "fails not have_selector(:text) if a node with type=text exists" do
lambda { @text_only.should_not have_selector(":text") }.should fail
end
it "works together with other selectors" do
@text_and_password.should have_selector("input:text[type*='te']")
end
end
describe ":password" do
it "passes have_selector(:password) if a node with type=password exists" do
@text_and_password.should have_selector(":password")
end
it "passes not have_selector(:text) if no node with text=text exists" do
@text_only.should_not have_selector(":password")
end
it "fails have_selector(:password) if no node with type=password exists" do
lambda { @text_only.should have_selector(":password") }.should fail
end
it "fails not have_selector(:password) if a node with type=password exists" do
lambda { @password_only.should_not have_selector(":password") }.should fail
end
it "works together with other selectors" do
@text_and_password.should have_selector("input:password[type*='pa']")
end
end
end

20
spec/webrat/rails/attaches_file_spec.rb
View File

@ -1,6 +1,6 @@
require File.expand_path(File.dirname(__FILE__) + '/helper')
describe "attaches_file" do
describe "attach_file" do
before do
@session = Webrat::TestSession.new
@ -14,7 +14,7 @@ describe "attaches_file" do
<form method="post" action="/widgets">
</form>
EOS
lambda { @session.attaches_file("Doc", "/some/path") }.should raise_error
lambda { @session.attach_file("Doc", "/some/path") }.should raise_error
end
it "should submit empty strings for blank file fields" do
@ -25,7 +25,7 @@ describe "attaches_file" do
</form>
EOS
@session.should_receive(:post).with("/widgets", { "widget" => { "file" => "" } })
@session.clicks_button
@session.click_button
end
it "should submit the attached file" do
@ -37,8 +37,8 @@ describe "attaches_file" do
</form>
EOS
@session.should_receive(:post).with("/widgets", { "widget" => { "file" => @uploaded_file } })
@session.attaches_file "Document", @filename
@session.clicks_button
@session.attach_file "Document", @filename
@session.click_button
end
it "should support collections" do
@ -52,9 +52,9 @@ describe "attaches_file" do
</form>
EOS
@session.should_receive(:post).with("/widgets", { "widget" => { "files" => [@uploaded_file, @uploaded_file] } })
@session.attaches_file "Document", @filename
@session.attaches_file "Spreadsheet", @filename
@session.clicks_button
@session.attach_file "Document", @filename
@session.attach_file "Spreadsheet", @filename
@session.click_button
end
it "should allow the content type to be specified" do
@ -66,7 +66,7 @@ describe "attaches_file" do
</form>
EOS
ActionController::TestUploadedFile.should_receive(:new).with(@filename, "image/png").any_number_of_times
@session.attaches_file "Picture", @filename, "image/png"
@session.clicks_button
@session.attach_file "Picture", @filename, "image/png"
@session.click_button
end
end

22
spec/webrat/rails/rails_session_spec.rb
View File

@ -19,31 +19,31 @@ describe Webrat::RailsSession do
Webrat::RailsSession.new(integration_session).response_code.should == 42
end
it "should delegate get to get_via_redirect on the integration session" do
it "should delegate get to request_via_redirect on the integration session" do
integration_session = mock("integration session")
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:get_via_redirect).with("url", "data", "headers")
integration_session.should_receive(:request_via_redirect).with(:get, "url", "data", "headers")
rails_session.get("url", "data", "headers")
end
it "should delegate post to post_via_redirect on the integration session" do
it "should delegate post to request_via_redirect on the integration session" do
integration_session = mock("integration session")
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:post_via_redirect).with("url", "data", "headers")
integration_session.should_receive(:request_via_redirect).with(:post, "url", "data", "headers")
rails_session.post("url", "data", "headers")
end
it "should delegate put to put_via_redirect on the integration session" do
it "should delegate put to request_via_redirect on the integration session" do
integration_session = mock("integration session")
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:put_via_redirect).with("url", "data", "headers")
integration_session.should_receive(:request_via_redirect).with(:put, "url", "data", "headers")
rails_session.put("url", "data", "headers")
end
it "should delegate delete to delete_via_redirect on the integration session" do
it "should delegate delete to request_via_redirect on the integration session" do
integration_session = mock("integration session")
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:delete_via_redirect).with("url", "data", "headers")
integration_session.should_receive(:request_via_redirect).with(:delete, "url", "data", "headers")
rails_session.delete("url", "data", "headers")
end
@ -51,14 +51,14 @@ describe Webrat::RailsSession do
it "should just pass on the path" do
integration_session = mock("integration session", :https! => nil)
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:get_via_redirect).with("/url", "data", "headers")
integration_session.should_receive(:request_via_redirect).with(:get, "/url", "data", "headers")
rails_session.get("http://www.example.com/url", "data", "headers")
end
end
context "the URL is https://" do
it "should call #https! with true before the request" do
integration_session = mock("integration session", :get_via_redirect => nil)
integration_session = mock("integration session", :request_via_redirect => nil)
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:https!).with(true)
rails_session.get("https://www.example.com/url", "data", "headers")
@ -67,7 +67,7 @@ describe Webrat::RailsSession do
context "the URL is http://" do
it "should call #https! with true before the request" do
integration_session = mock("integration session", :get_via_redirect => nil)
integration_session = mock("integration session", :request_via_redirect => nil)
rails_session = Webrat::RailsSession.new(integration_session)
integration_session.should_receive(:https!).with(false)
rails_session.get("http://www.example.com/url", "data", "headers")

4
spec/webrat/rails/rails_spec.rb
View File

@ -7,7 +7,7 @@
# EOS
# @page.stub!(:url).and_return("/current")
# @session.should_receive(:get).with("/current", {})
# @session.clicks_button
# @session.click_button
# end
#
# it "should follow fully qualified secure local links" do
@ -16,5 +16,5 @@
# EOS
# @session.should_receive(:https!).with(true)
# @session.should_receive(:get).with("/page/sub", {})
# @session.clicks_link "Jump to sub page"
# @session.click_link "Jump to sub page"
# end

35
webrat.gemspec
View File

@ -1,35 +0,0 @@
Gem::Specification.new do |s|
s.name = %q{webrat}
s.version = "0.2.1"
s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
s.authors = ["Bryan Helmkamp", "Seth Fitzsimmons"]
s.date = %q{2008-10-13}
s.description = %q{When comparing Webrat with an in-browser testing solution like Watir or Selenium, the primary consideration should be how much JavaScript the application uses. In-browser testing is currently the only way to test JS, and that may make it a requirement for your project. If JavaScript is not central to your application, Webrat is a simpler, effective solution that will let you run your tests much faster and more frequently. Initial development was sponsored by [EastMedia](http://www.eastmedia.com). Synopsis --------}
s.email = ["bryan@brynary.com", "seth@mojodna.net"]
s.extra_rdoc_files = ["History.txt", "MIT-LICENSE.txt", "Manifest.txt", "README.txt", "TODO.txt"]
s.files = ["History.txt", "MIT-LICENSE.txt", "Manifest.txt", "README.txt", "Rakefile", "TODO.txt", "init.rb", "install.rb", "lib/webrat.rb", "lib/webrat/core.rb", "lib/webrat/core/assertions.rb", "lib/webrat/core/field.rb", "lib/webrat/core/flunk.rb", "lib/webrat/core/form.rb", "lib/webrat/core/label.rb", "lib/webrat/core/link.rb", "lib/webrat/core/logging.rb", "lib/webrat/core/scope.rb", "lib/webrat/core/select_option.rb", "lib/webrat/core/session.rb", "lib/webrat/mechanize.rb", "lib/webrat/mechanize/mechanize_session.rb", "lib/webrat/rails.rb", "lib/webrat/rails/rails_session.rb", "lib/webrat/rails/redirect_actions.rb", "lib/webrat/rails/session.rb", "lib/webrat/selenium.rb", "lib/webrat/selenium/selenium_session.rb", "mechanize_spike.rb", "selenium_spike.rb", "spec/api/attaches_file_spec.rb", "spec/api/checks_spec.rb", "spec/api/chooses_spec.rb", "spec/api/clicks_button_spec.rb", "spec/api/clicks_link_spec.rb", "spec/api/fills_in_spec.rb", "spec/api/reloads_spec.rb", "spec/api/save_and_open_spec.rb", "spec/api/selects_spec.rb", "spec/api/should_not_see_spec.rb", "spec/api/should_see_spec.rb", "spec/api/visits_spec.rb", "spec/api/within_spec.rb", "spec/fakes/test_session.rb", "spec/integration/rails_spec.rb", "spec/rcov.opts", "spec/spec.opts", "spec/spec_helper.rb", "spec/webrat/core/logging_spec.rb", "spec/webrat/core/session_spec.rb", "spec/webrat/rails/rails_session_spec.rb", "webrat.gemspec"]
s.has_rdoc = true
s.homepage = %q{- [Code on GitHub](http://github.com/brynary/webrat)}
s.rdoc_options = ["--main", "README.txt"]
s.require_paths = ["lib"]
s.rubyforge_project = %q{webrat}
s.rubygems_version = %q{1.2.0}
s.summary = %q{Ruby Acceptance Testing for Web applications}
if s.respond_to? :specification_version then
current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
s.specification_version = 2
if current_version >= 3 then
s.add_runtime_dependency(%q<hpricot>, [">= 0.6"])
s.add_development_dependency(%q<hoe>, [">= 1.7.0"])
else
s.add_dependency(%q<hpricot>, [">= 0.6"])
s.add_dependency(%q<hoe>, [">= 1.7.0"])
end
else
s.add_dependency(%q<hpricot>, [">= 0.6"])
s.add_dependency(%q<hoe>, [">= 1.7.0"])
end
end