adva-core 0.0.1

data/lib/testing/factories.rb

@@ -0,0 +1,30 @@
+Factory.define :site do |f|
+  f.account Account.first || Account.create!
+  f.name    'adva-cms'
+  f.host    'www.example.com'
+  f.title   'adva-cms'
+  f.sections_attributes [{
+    :type => 'Page',
+    :name => 'Home',
+    :article_attributes => {
+      :body => 'Body'
+    }
+  }]
+  f.after_create { |site| Factory(:admin) }
+end
+
+Factory.define :section do |f|
+  f.site { Site.first || Factory(:site) }
+  f.name 'Home'
+end
+
+Factory.define :page do |f|
+  f.site { Site.first || Factory(:site) }
+  f.name 'Home'
+end
+
+Factory.define :content do |f|
+  f.site { Site.first || Factory(:site) }
+  f.section { Section.first || Factory(:section) }
+  f.title 'Content'
+end

data/lib/testing/helpers/global_helpers.rb

@@ -0,0 +1,9 @@
+module GlobalHelpers
+  def site
+    Site.first || raise("Could not find a site. Maybe you want to set one up in your story background?")
+  end
+
+  def account
+    Account.first || raise("Could not find a site. Maybe you want to set one up in your story background?")
+  end
+end

data/lib/testing/paths.rb

@@ -0,0 +1,54 @@
+module Adva::Core::Paths
+  def path_to(page)
+    case page
+
+    when /^\//
+      page
+
+    when /^the home\s?page$/
+      '/'
+
+    when /^the site installation page$/
+      new_installation_path
+
+    when /^the site installation confirmation page$/
+      installation_path(Site.last)
+
+    when /^the "([^"]*)" section page$/
+      section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
+      polymorphic_path(section)
+
+    when /^the admin sites page$/
+      polymorphic_path([:admin, :sites])
+
+    when /^the admin dashboard page$/
+      site = Site.first
+      polymorphic_path([:admin, site])
+
+    when /^the admin dashboard page for the site on "([^"]*)"$/
+      site = Site.find_by_host($1) || raise("could not find site with host #{$1}")
+      polymorphic_path([:admin, site])
+
+    when /^the admin sections page$/
+      site = Site.first
+      polymorphic_path([:admin, site, :sections])
+
+    when /^the admin "([^"]*)" section page$/
+      site = Site.first
+      section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
+      polymorphic_path([:admin, site, section])
+
+    when /^the admin "([^"]*)" section settings page$/
+      site = Site.first
+      section = Section.where(:name => $1).first || raise("could not find section named #{$1}")
+      polymorphic_path([:edit, :admin, site, section])
+
+    else
+      named_route_helper = page.gsub(/(\Athe )|( page\Z)/, '').gsub(/ +/, '_').downcase + '_path'
+      raise "Can't find mapping from \"#{page}\" to a path.\nNow, go and add a mapping in #{__FILE__}" unless respond_to?(named_route_helper)
+      send named_route_helper
+    end
+  end
+end
+
+World(Adva::Core::Paths)

data/lib/testing/step_definitions/common_steps.rb

@@ -0,0 +1,279 @@
+Given 'a site' do
+  @site = Factory(:site)
+end
+
+# TODO what's this?
+Transform /^table:name,product_name$/ do |table|
+  transformed_table = table.hashes.map do |row|
+    row.merge('product_id' => Product.find_by_name(row.delete('product_name')).id)
+  end
+  Cucumber::Ast::Table.new(transformed_table)
+end
+
+# Examples:
+# 1. Given the following products:
+# Also supports namespaced models, (cnet) indicating the namespace Cnet
+# 2. Given the following (cnet) products:
+Given /^the following ((?:\([a-z ]+\) )?(?:[\w]+)):$/ do |type, table|
+  type = type.gsub(/^\(([a-z ]+)\) /, "\\1/").gsub(' ', '_').singularize
+  table.hashes.each do |attributes|
+    type = attributes.delete('type').underscore if attributes.key?('type')
+    attributes['site'] = site if type.classify.constantize.column_names.include?('site_id')
+    Factory(type, attributes)
+  end
+end
+
+Given /^a site with the following sections:$/ do |table|
+  Site.all.map(&:destroy)
+  @site = Factory(:site, :sections_attributes => [])
+  Given "the following sections:", table
+end
+
+Given /^a site with a (\w+) named "([^"]+)"$/ do |section, name|
+  Site.all.map(&:destroy)
+  @site = Factory(:site, :sections_attributes => [])
+  Given %(a #{section} named "#{name}")
+end
+
+# e.g. a blog named "Blog"
+Given /^an? (\w+) (name|title)d "([^"]+)"$/ do |model, attribute, value|
+  model = model.classify.constantize
+  attributes = { attribute => value }
+  attributes[:site_id]    = site.id    if model.column_names.include?('site_id')
+  attributes[:account_id] = account.id if model.column_names.include?('account_id')
+  model.where(attributes).first || model.create!(attributes)
+end
+
+Given /^an? (\w+) with the following attributes:$/ do |model, table|
+  Factory(model, table.rows_hash)
+end
+
+# e.g. a post titled "Post" for the blog "Blog"
+# e.g. a category named "Category" belonging to the blog "Blog"
+Given /^an? (\w+) (name|title)d "([^"]+)" (?:for|belonging to) the (\w+) "([^"]+)"$/ do |model, attribute, value, section, name|
+  section = Given(%(a #{section} named "#{name}"))
+  collection = section.send(model.underscore.pluralize)
+  attributes = { attribute => value }
+  collection.where(attributes).first || collection.create!(attributes)
+end
+
+# e.g. a post with the title "Post" for the blog "Blog"
+# e.g. a post with the title "Post" belonging to the blog "Blog"
+Given /^an? (\w+) with the (\w+) "([^"]+)" (?:for|belonging to) the (\w+) "([^"]+)"$/ do |model, attribute, value, section, name|
+  section = Given(%(a #{section} named "#{name}"))
+  collection = section.send(model.underscore.pluralize)
+  attributes = { attribute => value }
+  collection.where(attributes).first || collection.create!(attributes)
+end
+
+Given /^(\w+)s with the following attributes:$/ do |model, table|
+  table.hashes.each do |attributes|
+    Factory(model, attributes)
+  end
+end
+
+When /^(.+) that link$/ do |step|
+  raise "no last link" if @last_link.blank?
+  When %(#{step} "#{@last_link}")
+end
+
+When /^I (press|click) "(.*)" in the row (of the ([a-z ]+) table )?where "(.*)" is "(.*)"$/ do |press_or_click, link_or_button, _, 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")
+  assert !table_header_cells.empty?, "could not find table header cell '#{header}'"
+  header_id = body.xpath("//#{table_xpath}/descendant::th[normalize-space(text())='#{header}']/@id").first.value
+  row_id = body.xpath("//#{table_xpath}/descendant::td[@headers='#{header_id}'][normalize-space(text())='#{cell_content}']/ancestor::tr/@id").first.value
+  within("##{row_id}") do
+    send({'press' => 'click_button', 'click' => 'click_link'}[press_or_click], link_or_button)
+  end
+end
+
+When /^I click on the link 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"
+  link = email.body.to_s =~ %r((http://[^\s"]+)) && $1
+  get link
+end
+
+Then /^there should be an? (\w+)$/ do |model|
+  assert @last_record = model.classify.constantize.first, "could not find any #{model}"
+end
+
+Then /^there should be an? (\w+) named "([^\"]+)"$/ do |model, name|
+  assert @last_record = model.classify.constantize.where(:name => name).first, "could not find any #{model} named #{name}"
+end
+
+Then /^there should not be an? (\w+) named "([^"]*)"$/ do |model, name|
+  assert !model.classify.constantize.where(:name => name).first, "expected no #{model} named #{name} exists, but found one"
+end
+
+Then /^there should be a (\w+) with the following attributes:$/ do |model, table|
+  assert @last_record = model.classify.constantize.where(table.rows_hash).first, "could not find a #{model} with #{table.rows_hash.inspect}"
+end
+
+Then /^there should be (\w+)s with the following attributes:$/ do |model, table|
+  table.hashes.each do |attributes|
+    assert model.classify.constantize.where(attributes).first, "could not find a #{model} with #{attributes.inspect}"
+  end
+end
+
+Then /^that (\w+) should have an? (\w+) with the following attributes:$/ do |last, model, table|
+  assert @last_record.is_a?(last.classify.constantize), "wrong type for last #{last}"
+  assert @last_record.send(model.pluralize).where(table.rows_hash).first, "could not find a #{model} with #{table.rows_hash.inspect}"
+end
+
+Then /^that (\w+) should have (\w+)s with the following attributes:$/ do |last, model, table|
+  assert @last_record.is_a?(last.classify.constantize), "wrong type for last #{last}"
+  table.hashes.each do |attributes|
+    assert @last_record.send(model.pluralize).where(attributes).first, "could not find a #{model} with #{attributes.inspect}"
+  end
+end
+
+Then /^the title should be "([^"]+)"$/ do |title|
+  assert_select('title', title)
+end
+
+Then /^I should see a link "([^"]+)"$/ do |link|
+  @last_link = link
+  assert_select('a', link)
+end
+
+Then /^I should not see any (\w+)$/ do |type|
+  assert_select(".#{type.singularize}", :count => 0) # .#{type},
+end
+
+Then /^I should see an? (\w+)$/ do |type|
+  assert_select(".#{type}")
+end
+
+Then /^I should see an? (\w+) (?:titled|named) "([^"]+)"$/ do |type, text|
+  assert_select(".#{type} h2", text)
+end
+
+Then /^I should see an? (\w+) containing "([^"]+)"$/ do |type, text|
+  assert_select(".#{type}", /#{text}/)
+end
+
+Then /^I should see an? (\w+) list$/ do |type|
+  assert_select(".#{type}.list")
+end
+
+Then /^I should see a list of (\w+)$/ do |type|
+  assert_select(".#{type}.list")
+end
+
+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(', '))
+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)
+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|
+    table.rows_hash.each do |name, value|
+      assert_equal value, webrat.current_scope.field_labeled(name).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 "\nActual table:#{actual_table.to_s}\n"
+    puts "Expected table:#{expected_table.to_s}\n"
+    puts "Difference:#{diff_table.to_s}\n"
+    raise
+  end
+end
+
+Then /^I should see the "([^"]+)" page$/ do |name|
+  assert_select('h2', name)
+end
+
+Then(/(?:\$|eval) (.*)$/) do |code|
+  pp eval(code)
+end
+
+Then /^I should see a flash (error|notice|message) "(.+)"$/ do |message_type, message|
+  assert_match message, flash_cookie[message_type].to_s
+end
+
+Then /^I should not see a flash (error|notice) "(.+)"$/ do |message_type, message|
+  assert_no_match /message/, flash_cookie[message_type].to_s
+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
+end
+
+Then /^the following emails should have been sent:$/ do |expected_emails|
+  expected_emails.hashes.each do |attributes|
+    assert_email_sent(attributes)
+  end
+end
+
+# Then /^I should see a "([^"]+)" table with the following entries:$/ do |table_id, expected_table|
+#   html_table = table(tableish("table##{table_id} tr", 'td,th'))
+#   expected_table.diff!(html_table)
+# end
+
+# TODO somehow merge this with what's in within_steps.rb
+#
+# Then I should see a comment within the sidebar
+# Will look for '#sidebar .comment'
+# Then I should see the cart within the sidebar
+# Will look for '#sidebar #cart'
+Then /^I should see (an?|the) ([a-z ]+) within the ([a-z ]+)$/ do |a_or_the, selector, context_selector|
+  within("##{context_selector}") do |context|
+    assert_select({'a' => '.', 'the' => '#'}[a_or_the]+selector)
+  end
+end
+
+Then /^"([^"]*)" should be filled in with "([^"]*)"$/ do |field, value|
+  field = webrat.field_labeled(field)
+  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"
+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"
+  assert_equal value, selected.text
+end
+
+Then /^I should see "([^"]*)" formatted as a "([^"]*)" tag$/ do |value, tag|
+  assert_select(tag, value)
+end
+
+Then "debug" do
+  debugger
+  true
+end

data/lib/testing/step_definitions/menu_steps.rb

@@ -0,0 +1,11 @@
+Then /^the menu should contain the following items:$/ do |menu|
+  menu.hashes.each do |item|
+    if item['url'].empty?
+      assert_select("#{item[:menu]} li h4", item['text'])
+    else
+      active = item[:active] == 'yes' ? '.active' : ':not(.active)'
+      url    = item['url'].gsub('?', '\?').gsub('[', '\[').gsub(']', '\]').gsub(/\d+/, '[\d]*')
+      assert_select("#{item[:menu]} li#{active} a[href=?]", %r(#{url}), item['text'])
+    end
+  end
+end

data/lib/testing/step_definitions/routes_steps.rb

@@ -0,0 +1,18 @@
+Given 'the routes are loaded' do
+  @routes = Rails.application.routes
+end
+
+Then 'the following routes should be recognized:' do |table|
+  table.hashes.each do |options|
+    method_and_path  = options.slice('method', 'path')
+    expected_options = options.except('method', 'path', 'params')
+    expected_options.each { |name, value| expected_options.delete(name) if value.blank? }
+
+    options['params'].split(',').each do |param|
+      name, value = param.split(':').map(&:strip)
+      expected_options[name] = value
+    end if options['params']
+
+    assert_recognizes(expected_options.symbolize_keys, method_and_path.symbolize_keys)
+  end
+end

data/lib/testing/step_definitions/transforms.rb

@@ -0,0 +1,43 @@
+# For date column cells named created_on, updated_at etc. this transforms the
+# corresponding cell's value to a datetime in the current time zone (i.e. this
+# works for both normal tables and row_hash tables):
+timezonify = lambda do |table|
+  dates = table.headers.select { |header| header =~ /(_at|_on)$/ }
+  dates.each { |date| table.map_column!(date) { |date| DateTime.parse(date).in_time_zone } }
+  table.transpose
+end
+
+objectify = lambda do |table|
+  types = Section.types.map(&:underscore) << 'section' << 'site'
+  sections = table.headers.select { |header| types.include?(header) }
+  sections.each { |key| table.map_column!(key) { |value| key.gsub('_id', '').classify.constantize.find_by_name(value) } }
+  table.transpose
+end
+
+foreign_keyify = lambda do |table|
+  types = Section.types.map(&:underscore) << 'section' << 'site'
+  keys = types.map { |type| "#{type}_id" }
+  keys = table.headers.select { |header| keys.include?(header) }
+  keys.each { |key| table.map_column!(key) { |value| key.gsub('_id', '').classify.constantize.find_by_name(value).try(:id).to_s } }
+  table.transpose
+end
+
+# FIXME must be here because one apparently can't register multiple transforms for the
+# same regex (like /^table:/) in cucumber. should really be in adva-categories though.
+categoryify = lambda do |table|
+  if table.headers.include?('categories')
+    table.map_column!('categories') do |categories|
+      names = categories.split(',').map(&:strip)
+      Category.where(:name => names).all
+    end
+  end
+  table.transpose
+end
+
+Transform /^table:/ do |table|
+  table = timezonify.call(timezonify.call(table))
+  table = objectify.call(objectify.call(table))
+  table = foreign_keyify.call(foreign_keyify.call(table))
+  table = categoryify.call(categoryify.call(table))
+  table
+end