adva-core 0.0.9 → 0.0.13

data/lib/testing/step_definitions/common_steps.rb

@@ -1,3 +1,11 @@
+Then /^the "([^\"]*)" field should be empty$/ do |field|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(field).value.should be_blank
+  else
+    assert field_labeled(field).value.blank?
+  end
+end
+
 Given 'a site' do
   @site = Factory(:site)
 end
@@ -79,35 +87,26 @@ When /^(.+) that link$/ do |step|
 end
 
 When /^I (press|click|follow) "(.*)" in the row (of the ([a-z ]+) table )?where "(.*)" is "(.*)"$/ do |action, target, _, table_id, header, content|
-  body = Nokogiri::HTML(response.body)
-  table_xpath = table_id.nil? ? 'table' : "table[@id='#{table_id.gsub(/ /, '_')}']"
-  headers = body.xpath("//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']/@id")
+  table_id =  table_id.gsub(/ /, '_') unless table_id.nil?
+  table_xpath = table_id.nil? ? 'table' : "table[@id='#{table_id}']"
+  headers = page.all(:xpath, "//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']")
   assert !headers.empty?, "could not find table header cell #{header.inspect}"
 
-  header_id = headers.first.value
+  header_id = headers.first['id']
   cell_path = "//#{table_xpath}/descendant::td[@headers='#{header_id}']"
   content   = "normalize-space(text())='#{content}'"
-  tag_path  = "#{cell_path}[#{content}]/ancestor::tr/@id"
-  nested_tag_path = "#{cell_path}/descendant::*[#{content}]/ancestor::tr/@id"
+  tag_path  = "#{cell_path}[#{content}]/ancestor::tr"
+  nested_tag_path = "#{cell_path}/descendant::*[#{content}]/ancestor::tr"
 
-  rows = body.xpath([tag_path, nested_tag_path].join('|'))
+  rows = page.all(:xpath, [tag_path, nested_tag_path].join('|'))
   assert !rows.empty?, "could not find table row where a cell has the header id #{header_id.inspect} and the content #{content.inspect}"
 
   map = { 'press' => 'click_button', 'click' => 'click_link' }
-  within("##{rows.first.value}") { map[action] ? send(map[action], target) : When(%(I #{action} "#{target}")) }
-end
-
-When /^I order the (.*)s list by "([^"]*)"$/ do |model, order|
-  When %(I select "#{order}" from "#{model}s_order")
-  select = Webrat::Locators::FieldLocator.new(webrat, webrat.dom, "#{model}s_order", Webrat::SelectField).locate!
-  select.send(:form).submit
-end
-
-When /^I visit the url from the email to (.*)$/ do |to|
-  email = ::ActionMailer::Base.deliveries.detect { |email| email.to.include?(to) }
-  assert email, "email to #{to} could not be found"
-  url = email.body.to_s =~ %r((http://[^\s"]+)) && $1
-  visit(url)
+  if table_id.nil?
+    within("##{rows.first['id']}") { map[action] ? send(map[action], target) : When(%(I #{action} "#{target}")) }
+  else
+    within("table##{table_id} ##{rows.first['id']}") { map[action] ? send(map[action], target) : When(%(I #{action} "#{target}")) }
+  end
 end
 
 # Examples:
@@ -115,25 +114,24 @@ end
 # I should not see a product row where "Name" is "Apple Powerbook"
 # I should see a row in the products table where "Name" is "Apple Powerbook"
 Then /^I should (not )?see a ([a-z ]+ )?row (?:of the ([a-z ]+) table )?where "(.*)" is "(.*)"$/ do |optional_not, row_classes, table_id, header, cell_content|
-  body = Nokogiri::HTML(response.body)
-  table_xpath = table_id.nil? ? 'table' : "table[@id='#{table_id.gsub(/ /, '_')}']"
-  table_header_cells = body.xpath("//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']/@id")
+  table_xpath = table_id.nil? ? 'table' : "table[@id='#{table_id.gsub(/ /, '_')}' or @id='#{table_id.gsub(/ /, '-')}']"
+  table_header_cells = page.all(:xpath, "//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']")
 
   unless optional_not.present?
     assert !table_header_cells.empty?, "could not find table header cell '#{header}'"
   end
-  header_id = body.xpath("//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']/@id").first.try(:value)
+  header_id = table_header_cells.first['id']
 
   class_condition = row_classes.to_s.split(' ').map do |row_class|
     "contains(concat(' ', normalize-space(@class), ' '), ' #{row_class} ')"
   end.join(' and ')
   tr_xpath = class_condition.empty? ? 'ancestor::tr' : "ancestor::tr[#{class_condition}]"
-  xpath_result = body.xpath("//#{table_xpath}/descendant::td[@headers='#{header_id}'][normalize-space(text())='#{cell_content}']/#{tr_xpath}")
+  final_path = "//#{table_xpath}/descendant::td[@headers='#{header_id}'][normalize-space(text())='#{cell_content}']/#{tr_xpath}"
 
   if optional_not.present?
-    assert xpath_result.empty?, "Expected not find a row where #{header.inspect} is #{cell_content}."
+    assert page.has_no_xpath?(final_path), "Expected not find a row where #{header.inspect} is #{cell_content}."
   else
-    assert xpath_result.any?, "Expected to find at least one row where #{header.inspect} is #{cell_content}."
+    assert page.has_xpath?(final_path), "Expected to find at least one row where #{header.inspect} is #{cell_content}."
   end
 end
 
@@ -172,62 +170,52 @@ Then /^that (\w+) should have (\w+)s with the following attributes:$/ do |last,
 end
 
 Then /^the title should be "([^"]+)"$/ do |title|
-  assert_select('title', title)
+  Then %Q{I should see "#{title}" within "title"}
 end
 
 # TODO: This is an almost duplicate step
 # Use the one with un-quoted 'thing' expression
 Then /^I should see (an?|the) "([^"]+)"$/ do |kind, thing|
   kind = { 'a' => '.', 'the' => '#' }[kind]
-  assert_select("#{kind}#{thing}")
+  assert page.has_css?("#{kind}#{thing}")
 end
 
 Then /^I should see a link "([^"]+)"$/ do |link|
   @last_link = link
-  assert_select('a', link)
+  assert page.has_css?('a', :text => link)
 end
 
 Then /^I should not see any ([a-z_ ]+)$/ do |type|
-  assert_select(".#{type.gsub(' ', '_').singularize}", :count => 0)
+  assert page.has_no_css?(".#{type.gsub(' ', '_').singularize}")
 end
 
+# FIXME: this step and the ones above do not deal with use perception
+#  for example: "I should see a fn0rd" looks nice, but users cannot see elements, only text
 Then /^I should see an? (\w+)$/ do |type|
-  assert_select(".#{type}")
+  assert page.has_css?(".#{type}")
 end
 
 Then /^I should see a "([^"]*)" select box with the following options:$/ do |name, options|
-  select = Webrat::Locators::FieldLocator.new(webrat, webrat.dom, 'products_order', Webrat::SelectField).locate!
-  actual = select.options.map(&:inner_text).uniq
+  field = find_field(name)
+  actual = field.all(:css, 'option').map {|o| o.text }
   expected = options.raw.flatten[1..-1] # ignores the first row
   assert_equal expected, actual
 end
 
-Then /^I should see an? (\w+) (?:titled|named) "([^"]+)"$/ do |type, text|
-  assert_select(".#{type} h2", text)
+Then /^I should see an? (\w+) (?:titled|named) "([^"]+)"$/ do |thingy, text|
+  Then %Q~I should see "#{text}" within ".#{thingy} h2"~
 end
 
-Then /^I should see an? (\w+) containing "([^"]+)"$/ do |type, text|
-  assert_select(".#{type}", /#{text}/)
-end
-
-# TODO: the sinature of this step should really be:
-# I should see 'foo' within 'bar'
-# However, the generic "within 'bar'" meta step uses 'within' which doesn't currently work with assertions
-# only with navigation ('click', 'press')
-Then /^the ([^"]+) should(?: (not))? contain "([^"]+)"$/ do |container_name, optional_negation, text|
-  container_id = container_name.gsub(' ', '_')
-  # 'within' doesn't currently work with assertions, so we need to resort to xpath
-  # within('#' + container_id) { assert_contain text }
-  assert(parsed_html.xpath("//*[@id=\"#{container_id}\"]").any?, "Could not find the #{container_name}")
-  assert(parsed_html.xpath("//*[@id=\"#{container_id}\"]/descendant::*[contains(normalize-space(text()), \"#{text}\")]").send(optional_negation ? :'none?' : :'any?'), "Could not see '#{text}' in the #{container_name}")
+Then /^I should see an? (\w+) containing "([^"]+)"$/ do |thingy, text|
+  Then %Q~I should see "#{text}" within ".#{thingy}"~
 end
 
 Then /^I should see an? (\w+) list$/ do |type|
-  assert_select(".#{type}.list")
+  assert page.has_css?(".#{type}.list")
 end
 
 Then /^I should see a list of (\w+)$/ do |type|
-  assert_select(".#{type}.list")
+  assert page.has_css?(".#{type}.list")
 end
 
 Then /^the (.*) list should display (.*)s in the following order:$/ do |list, model, values|
@@ -244,32 +232,35 @@ Then /^I should see an? ([a-z ]+) form$/ do |type|
   tokens = type.split(' ')
   types = [tokens.join('_'), tokens.reverse.join('_')]
   selectors = types.map { |type| "form.#{type}, form##{type}" }
-  assert_select(selectors.join(', '))
+  assert page.has_css?(selectors.join(', '))
 end
 
 Then /^I should not see an? ([a-z ]+) form$/ do |type|
   type = type.gsub(' ', '_') #.gsub(/edit_/, '')
-  assert_select("form.#{type}, form##{type}", :count => 0)
+  assert page.has_no_css?("form.#{type}, form##{type}")
 end
 
-Then /^I should see an? ([a-z ]+) form with the following values:$/ do |type, table|
-  type = type.gsub(' ', '_') #.gsub(/edit_/, '')
-  assert_select("form.#{type}, form##{type}") do |form|
+Then /^I should see an? ([a-z ]+) form with the following values:$/ do |kind, table|
+  with_scope("#{kind} form") do
     table.rows_hash.each do |name, value|
-      assert_equal value, webrat.current_scope.field_labeled(name).value
+      Then %Q~the "#{name}" field should contain "#{value}"~
     end
   end
 end
 
-Then /^I should see a "(.+)" table with the following entries:$/ do |table_id, expected_table|
-  actual_table = table(tableish("table##{table_id} tr", 'td,th'))
-  begin
-    diff_table = expected_table.dup
-    diff_table.diff!(actual_table.dup)
-  rescue
-    puts tables_differ_message(actual_table, expected_table, diff_table)
-    raise
+Then /^I should see a "(.+)" table with the following entries:$/ do |dom_id, expected|
+  actual = table(tableish("table##{dom_id} tr", 'th,td'))
+  expected.diff! actual
+end
+
+Then /^I should see a "(.+)" list with the following entries:$/ do |dom_id, expected|
+  value_selector = expected.column_names.map {|n| '.' + n.downcase.gsub(/[ _]/, '-') }.join(',')
+  list = tableish("ul##{dom_id} li", value_selector)
+  actual = table( [expected.column_names] + list )
+  actual.column_names.each do |col|
+    actual.map_column!(col) { |text| text.sub(/\n/,' ') }
   end
+  expected.diff! actual
 end
 
 Then /^I should see a "(.+)" table with the following entries in no particular order:$/ do |table_id, expected_table|
@@ -286,7 +277,7 @@ def tables_differ_message(actual, expected, diff = nil)
 end
 
 Then /^I should see the "([^"]+)" page$/ do |name|
-  assert_select('h2', name)
+  Then %Q~I should see "#{name}" within "h2"~
 end
 
 Then(/(?:\$|eval) (.*)$/) do |code|
@@ -302,13 +293,8 @@ Then /^I should not see a flash (error|notice) "(.+)"$/ do |message_type, messag
 end
 
 Then /^I should (see|not see) the error "([^"]+)" for attribute "([^"]+)" of the "([^"]+)"$/ do |should_see, error_msg, attribute, model|
-  if should_see == 'see' # ugh ...
-    assert_select "*[id*=#{model.downcase.gsub(' ', '_')}_#{attribute.downcase.gsub(' ', '_')}] + span.error",
-      :text => error_msg
-  elsif should_see == 'not see'
-    assert_select "*[id*=#{model.downcase.gsub(' ', '_')}_#{attribute.downcase.gsub(' ', '_')}] + span.error",
-      :text => error_msg, :count => 0
-  end
+  selector = "*[id*=#{model.downcase.gsub(' ', '_')}_#{attribute.downcase.gsub(' ', '_')}] + span.error"
+  Then %Q~I should #{should_see} "#{error_msg}" within "#{selector}"~
 end
 
 Then /^the following emails should have been sent:$/ do |expected_emails|
@@ -322,34 +308,27 @@ Then /^no emails should have been sent$/ do
 end
 
 Then /^"([^"]*)" should be filled in with "([^"]*)"$/ do |field, value|
-  field = webrat.field_labeled(field)
-  assert_equal value, field.value
+  field = find_field(field)
+  field_value = (field.tag_name == 'textarea') ? field.text : field.value
+  assert_equal(value, field_value)
 end
 
-Then /^"([^"]*)" should be checked$/ do |label|
-  field = webrat.field_labeled(label)
-  assert field.checked?, "expected the checkbox #{label} to be checked"
-end
-
-Then /^"([^"]*)" should not be checked$/ do |label|
-  field = webrat.field_labeled(label)
-  assert !field.checked?, "expected the checkbox #{label} not to be checked"
+Then /^"([^"]*)" should (be|not be) checked$/ do |label, be_or_not_to_be|
+  Then %Q{the "#{label}" checkbox should #{be_or_not_to_be} checked}
 end
 
 Then /^"([^"]*)" should be selected as "([^"]*)"$/ do |value, label|
-  select = webrat.field_labeled(label)
-  assert select, "count not find a select field labeled #{label}"
-  selected = select.element.xpath(".//option[@selected = 'selected']").first
-  assert selected, "could not find a selected option"
+  select_box = find_field(label)
+  selected = select_box.find(:xpath, ".//option[@selected = 'selected']")
   assert_equal value, selected.text
 end
 
 Then /^I should see "([^"]*)" formatted as a "([^"]*)" tag$/ do |value, tag|
-  assert_select(tag, value)
+  Then %Q~I should see "#{value}" within "#{tag}"~
 end
 
-Then(/^I should see (\d+|no|one|two|three) ([a-z ]+?)(?: in the ([a-z ]+))?$/) do |amount, item_class, container_id|
-  container_selector = container_id ? '#' + container_id.gsub(' ', '_') : nil
+# TODO remove the manual (?: in..) to leverage cucumber selectors
+Then(/^I should see (\d+|no|one|two|three) ([-a-z ]+?)(?: in (the [a-z -]+))?$/) do |amount, item_class, container|
   amount = case amount
     when 'no' then 0
     when 'one' then 1
@@ -358,13 +337,23 @@ Then(/^I should see (\d+|no|one|two|three) ([a-z ]+?)(?: in the ([a-z ]+))?$/) d
     else amount.to_i
   end
   item_selector = '.' + item_class.gsub(' ', '_').singularize
-  # assertions do not work with 'within' yet, so we need to resort to cancatenating selectors:
-  # container_selector ? within(container_selector) { assert_select(item_selector) } : assert_select(item_selector)
-  if container_selector
-    assert_select container_selector
-    assert_select [container_selector, item_selector].join(' '), amount
+  with_scope container do
+    assert page.has_css?(item_selector,:count => amount)
+  end
+end
+
+Then /^the "([^"]*)" radio button should (be|not be) checked$/ do |label, be_or_not_to_be|
+  Then %Q~the "#{label}" checkbox should #{be_or_not_to_be} checked~
+end
+
+Then /^(?:|I )should not be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should_not == path_to(page_name)
   else
-    assert_select item_selector, amount
+    assert_not_equal path_to(page_name), current_path
   end
 end
 
+
+

data/lib/testing/step_definitions/debug_steps.rb

@@ -12,11 +12,18 @@ Then 'debug' do
   true
 end
 
-Then /^show me the page$/ do
-  save_and_open_page
+Then /^(?:|I )output the page$/ do
+  puts page.body
 end
 
-Then /^(?:|I )output the page$/ do
-  puts response.body
+When /^I pause$/ do
+  STDERR.puts "pausing - press enter to continue"
+  STDIN.gets
 end
 
+Then /^dump the table "([^"]*)"$/ do |table_name|
+  filename   = Rails.root.join('tmp').join("dump-#{table_name}.csv").expand_path
+  sql        = "COPY #{table_name} TO '#{filename}' WITH CSV HEADER"
+
+  ActiveRecord::Base.connection.execute sql
+end

data/lib/testing/step_definitions/email_steps.rb

@@ -0,0 +1,195 @@
+require 'email_spec/cucumber'
+# Commonly used email steps
+#
+# To add your own steps make a custom_email_steps.rb
+# The provided methods are:
+#
+# last_email_address
+# reset_mailer
+# open_last_email
+# visit_in_email
+# unread_emails_for
+# mailbox_for
+# current_email
+# open_email
+# read_emails_for
+# find_email
+#
+# General form for email scenarios are:
+#   - clear the email queue (done automatically by email_spec)
+#   - execute steps that sends an email
+#   - check the user received an/no/[0-9] emails
+#   - open the email
+#   - inspect the email contents
+#   - interact with the email (e.g. click links)
+#
+# The Cucumber steps below are setup in this order.
+
+module EmailHelpers
+  def current_email_address
+    # Replace with your a way to find your current email. e.g @current_user.email
+    # last_email_address will return the last email address used by email spec to find an email.
+    # Note that last_email_address will be reset after each Scenario.
+    last_email_address || "example@example.com"
+  end
+end
+
+World(EmailHelpers)
+
+#
+# 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
+
+#
+# Check how many emails have been sent/received
+#
+
+Then /^(?:I|they|"([^"]*?)") should receive (an|no|\d+) emails?$/ do |address, amount|
+  unread_emails_for(address).size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should have (an|no|\d+) emails?$/ do |address, amount|
+  mailbox_for(address).size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should receive (an|no|\d+) emails? with subject "([^"]*?)"$/ do |address, amount, subject|
+  unread_emails_for(address).select { |m| m.subject =~ Regexp.new(subject) }.size.should == parse_email_count(amount)
+end
+
+Then /^(?:I|they|"([^"]*?)") should receive an email with the following body:$/ do |address, expected_body|
+  open_email(address, :with_text => expected_body)
+end
+
+#
+# Accessing emails
+#
+
+# Opens the most recently received email
+When /^(?:I|they|"([^"]*?)") opens? the email$/ do |address|
+  open_email(address)
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with subject "([^"]*?)"$/ do |address, subject|
+  open_email(address, :with_subject => subject)
+end
+
+When /^(?:I|they|"([^"]*?)") opens? the email with text "([^"]*?)"$/ do |address, text|
+  open_email(address, :with_text => text)
+end
+
+#
+# Inspect the Email Contents
+#
+
+Then /^(?:I|they) should see "([^"]*?)" in the email subject$/ do |text|
+  current_email.should have_subject(text)
+end
+
+Then /^(?:I|they) should see \/([^"]*?)\/ in the email subject$/ do |text|
+  current_email.should have_subject(Regexp.new(text))
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email body$/ do |text|
+  current_email.default_part_body.to_s.should include(text)
+end
+
+Then /^(?:I|they) should see \/([^"]*?)\/ in the email body$/ do |text|
+  current_email.default_part_body.to_s.should =~ Regexp.new(text)
+end
+
+Then /^(?:I|they) should see the email delivered from "([^"]*?)"$/ do |text|
+  current_email.should be_delivered_from(text)
+end
+
+Then /^(?:I|they) should see "([^\"]*)" in the email "([^"]*?)" header$/ do |text, name|
+  current_email.should have_header(name, text)
+end
+
+Then /^(?:I|they) should see \/([^\"]*)\/ in the email "([^"]*?)" header$/ do |text, name|
+  current_email.should have_header(name, Regexp.new(text))
+end
+
+Then /^I should see it is a multi\-part email$/ do
+    current_email.should be_multipart
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email html part body$/ do |text|
+    current_email.html_part.body.to_s.should include(text)
+end
+
+Then /^(?:I|they) should see "([^"]*?)" in the email text part body$/ do |text|
+    current_email.text_part.body.to_s.should include(text)
+end
+
+#
+# Inspect the Email Attachments
+#
+
+Then /^(?:I|they) should see (an|no|\d+) attachments? with the email$/ do |amount|
+  current_email_attachments.size.should == parse_email_count(amount)
+end
+
+Then /^there should be (an|no|\d+) attachments? named "([^"]*?)"$/ do |amount, filename|
+  current_email_attachments.select { |a| a.filename == filename }.size.should == parse_email_count(amount)
+end
+
+Then /^attachment (\d+) should be named "([^"]*?)"$/ do |index, filename|
+  current_email_attachments[(index.to_i - 1)].filename.should == filename
+end
+
+Then /^there should be (an|no|\d+) attachments? of type "([^"]*?)"$/ do |amount, content_type|
+  current_email_attachments.select { |a| a.content_type.include?(content_type) }.size.should == parse_email_count(amount)
+end
+
+Then /^attachment (\d+) should be of type "([^"]*?)"$/ do |index, content_type|
+  current_email_attachments[(index.to_i - 1)].content_type.should include(content_type)
+end
+
+Then /^all attachments should not be blank$/ do
+  current_email_attachments.each do |attachment|
+    attachment.read.size.should_not == 0
+  end
+end
+
+Then /^show me a list of email attachments$/ do
+  EmailSpec::EmailViewer::save_and_open_email_attachments_list(current_email)
+end
+
+#
+# Interact with Email Contents
+#
+
+When /^(?:I|they) follow "([^"]*?)" in the email$/ do |link|
+  visit_in_email(link)
+end
+
+When /^(?:I|they) click the first link in the email$/ do
+  click_first_link_in_email
+end
+
+#
+# Debugging
+# These only work with Rails and OSx ATM since EmailViewer uses RAILS_ROOT and OSx's 'open' command.
+# Patches accepted. ;)
+#
+
+Then /^save and open current email$/ do
+  EmailSpec::EmailViewer::save_and_open_email(current_email)
+end
+
+Then /^save and open all text emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_text_emails
+end
+
+Then /^save and open all html emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_html_emails
+end
+
+Then /^save and open all raw emails$/ do
+  EmailSpec::EmailViewer::save_and_open_all_raw_emails
+end