Customised Cucumber step definitions for use with Test::Unit

email_steps.rb

#Commonly used email steps
#
# To add your own steps make a custom_email_steps.rb
# The provided methods are:
#
# reset_mailer
# open_last_email
# visit_in_email
# unread_emails_for
# mailbox_for
# current_email
# open_email
# read_emails_for
# find_email

module EmailHelpers
  def current_email_address
    current_user.email
  end
end
World(EmailHelpers)

# Use this step to reset the e-mail queue within a scenario.
# This is done automatically before each scenario.
Given /^(?:a clear email queue|no emails have been sent)$/ do
  reset_mailer
end

# Use this step to open the most recently sent e-mail.
When /^I open the email$/ do
  open_email(current_email_address)
end

When %r{^I follow "([^"]*?)" in the email$} do |link|
  visit_in_email(link)
end

Then /^I should receive (an|\d+) emails?$/ do |amount|
  amount = 1 if amount == "an"
  assert_equal amount.to_i, unread_emails_for(current_email_address).size
end

Then %r{^"([^"]*?)" should receive (an|\d+) emails?$} do |address, amount|
  amount = 1 if amount == "an"
  assert_equal amount.to_i, unread_emails_for(address).size
end

Then /^"([^\"]*)" should receive an email with text "([^\"]*)"$/ do |address, text|
  open_email(address)
  assert_match Regexp.new(text), current_email.body
end

Then %r{^"([^"]*?)" should have (an|\d+) emails?$} do |address, amount|
  amount = 1 if amount == "an"
  assert_equal amount.to_i, mailbox_for(address).size
end

Then %r{^"([^"]*?)" should not receive an email$} do |address|
  assert_nil find_email(address)
end

Then %r{^I should see "([^"]*?)" in the subject$} do |text|
  assert_match Regexp.new(text), current_email.subject
end

Then %r{^I should see "([^"]*?)" in the email$} do |text|
  assert_match Regexp.new(text), current_email.body
end

When %r{^"([^"]*?)" opens? the email with subject "([^"]*?)"$} do |address, subject|
  open_email(address, :with_subject => subject)
end

When %r{^"([^"]*?)" opens? the email with text "([^"]*?)"$} do |address, text|
  open_email(address, :with_text => text)
end

When %r{^I open the email with subject "([^"]*?)"$} do |subject|
  open_email(current_user.email, :with_subject => subject)
end

When /^I click the first link in the email$/ do
  click_first_link_in_email
end

webrat_steps.rb

require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))

# Commonly used webrat steps
# http://github.com/brynary/webrat

Given /^I am on (.+)$/ do |page_name|
  visit path_to(page_name)
  Then %{I should not see "translation_missing"}
  Then %{the HTML should be valid}
end

When /^I go to (.+)$/ do |page_name|
  visit path_to(page_name)
  Then %{I should not see "translation_missing"}
  Then %{the HTML should be valid}
end

When /^I press "([^\"]*)"$/ do |button|
  click_button(button)
  Then %{I should not see "translation_missing"}
  Then %{the HTML should be valid}
end

When /^I follow "([^\"]*)"$/ do |link|
  click_link(link)
  Then %{I should not see "translation_missing"}
  Then %{the HTML should be valid}
end

When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
  fill_in(field, :with => value)
end

When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
  select(value, :from => field)
end

# Use this step in conjunction with Rail's datetime_select helper. For example:
# When I select "December 25, 2008 10:00" as the date and time
When /^I select "([^\"]*)" as the date and time$/ do |time|
  select_datetime(time)
end

# Use this step when using multiple datetime_select helpers on a page or
# you want to specify which datetime to select. Given the following view:
#   <%= f.label :preferred %><br />
#   <%= f.datetime_select :preferred %>
#   <%= f.label :alternative %><br />
#   <%= f.datetime_select :alternative %>
# The following steps would fill out the form:
# When I select "November 23, 2004 11:20" as the "Preferred" date and time
# And I select "November 25, 2004 10:30" as the "Alternative" date and time
When /^I select "([^\"]*)" as the "([^\"]*)" date and time$/ do |datetime, datetime_label|
  select_datetime(datetime, :from => datetime_label)
end

# Use this step in conjunction with Rail's time_select helper. For example:
# When I select "2:20PM" as the time
# Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
# will convert the 2:20PM to 14:20 and then select it.
When /^I select "([^\"]*)" as the time$/ do |time|
  select_time(time)
end

# Use this step when using multiple time_select helpers on a page or you want to
# specify the name of the time on the form.  For example:
# When I select "7:30AM" as the "Gym" time
When /^I select "([^\"]*)" as the "([^\"]*)" time$/ do |time, time_label|
  select_time(time, :from => time_label)
end

# Use this step in conjunction with Rail's date_select helper.  For example:
# When I select "February 20, 1981" as the date
When /^I select "([^\"]*)" as the date$/ do |date|
  select_date(date)
end

# Use this step when using multiple date_select helpers on one page or
# you want to specify the name of the date on the form. For example:
# When I select "April 26, 1982" as the "Date of Birth" date
When /^I select "([^\"]*)" as the "([^\"]*)" date$/ do |date, date_label|
  select_date(date, :from => date_label)
end

When /^I check "([^\"]*)"$/ do |field|
  check(field)
end

When /^I uncheck "([^\"]*)"$/ do |field|
  uncheck(field)
end

When /^I choose "([^\"]*)"$/ do |field|
  choose(field)
end

When /^I attach the file at "([^\"]*)" to "([^\"]*)"$/ do |path, field|
  attach_file(field, path)
end

Then /^I should see "([^\"]*)"$/ do |text|
  assert_match Regexp.new(Regexp.escape(text)), response.body.gsub(/\s+/, " ")
end

Then /^I should not see "([^\"]*)"$/ do |text|
  assert_no_match Regexp.new(Regexp.escape(text)), response.body.gsub(/\s+/, " ")
end

Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
  assert_match Regexp.new(Regexp.escape(value)), field_labeled(field).value
end

Then /^the "([^\"]*)" field should not contain "([^\"]*)"$/ do |field, value|
  assert_no_match Regexp.new(Regexp.escape(value)), field_labeled(field).value
end

Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
  assert field_labeled(label).checked?
end

Then /^the "([^\"]*)" checkbox should not be checked$/ do |label|
  assert !field_labeled(label).checked?
end

Then /^I should be on (.+)$/ do |page_name|
  assert_match Regexp.new(path_to(page_name)), URI.parse(current_url).path
end

Then /^the HTML should be valid$/ do
  errors = errors_in_page(response.body)
  explanation = []
  errors.each do |error|
    line, message = parse_html_error(error)
    explanation << message
    explanation << html_context(response.body, line)
  end
  assert errors.empty?, explanation * "\n"
end

module HTMLValidation
  IGNORE = /Warning: trimming empty|lacks "summary" attribute|maxlength/

  def errors_in_page(html)
    require 'tidy'
    errors = []
    Tidy.path = Dir["/usr/lib/libtidy.{dylib,so}"].first
    Tidy.open(:show_warnings=>true, :char_encoding => "utf8") do |tidy|
      html = html.gsub(%r{<!\[CDATA\[.*?\]\]>}m){ $&.gsub(/\S/, "#") }
      tidy.clean(html)
      errors = tidy.errors.join("\n").split(/\n/).select{ |e| e !~ IGNORE }
    end
    return errors
  end

  def parse_html_error(error)
    m = error.match(/^line (\d+) column (\d+) - (.*)/)
    return m[1].to_i, "#{m[3]} at line #{m[1]} column #{m[2]}"
  end

  def html_context(html, line)
    lines = html.split(/\n/)
    top    = [0, line - 6].max
    bottom = [lines.length, line + 4].min
    (top..bottom).to_a.zip(lines[top..bottom]).map{ |number, text|
      "%s %3d | %s" % [number + 1 == line ? "*" : " ", number + 1, text]
    }.join("\n")
  end
end

World(HTMLValidation)