saucy 0.15.2 → 0.16.0

data/{lib/generators/saucy/features/templates/features → features/engine}/manage_billing.feature

@@ -81,7 +81,7 @@ Feature: Manage Billing
 
   Scenario: View past credit card charges
     Given I have signed up as "joe@example.com"
-    And the following transaction exist for the "Test" account:
+    And the following transactions exist for the "Test" account:
       | status  | amount | created_at        |
       | Settled | 20.00  | July 1, 2010      |
       | Settled | 5.00   | August 1, 2010    |

data/features/integration/run_features.feature

@@ -0,0 +1,46 @@
+@disable-bundler @generates-application
+Feature: generate a saucy application and run rake
+
+  Background:
+    When I generate a new rails application
+    And I copy the locked Gemfile from this project
+    And I append to "Gemfile" with:
+    """
+    gem "clearance", "~> 0.14.0"
+    gem "cucumber-rails"
+    gem "selenium-webdriver", "~> 2.16.0"
+    gem "capybara"
+    gem "factory_girl_rails"
+    gem "dynamic_form"
+    gem "database_cleaner"
+    gem "formtastic", "~> 1.2.4"
+    gem "rspec-rails"
+    gem "bourne"
+    gem "shoulda-matchers"
+    gem "launchy"
+    gem "timecop"
+    gem "jquery-rails"
+    gem "minitest", "~> 2.6.1", :platforms => :ruby_19
+    gem "fake_braintree", "~> 0.2.0"
+    """
+    When I add the "saucy" gem from this project as a dependency
+    And I successfully run `bundle install --local`
+    And I bootstrap the application for clearance
+    And I bootstrap the application for saucy
+
+  Scenario: generate a saucy application and run rake
+    When I run all cucumber scenarios
+    Then all cucumber scenarios should have passed
+    And all generators should have run successfully
+
+  Scenario: A new saucy app with custom views
+    When I successfully run `rails generate saucy:views`
+    And I give a more detailed new account message
+    And I run cucumber scenarios for customizations
+    Then all cucumber scenarios should have passed
+    And all generators should have run successfully
+
+  Scenario: A new saucy app with custom layouts
+    When I add a custom layout to the accounts index
+    And I run cucumber scenarios for customizations
+    Then all cucumber scenarios should have passed

data/features/step_definitions/clearance_steps.rb

@@ -43,3 +43,126 @@ When /^I configure "([^"]*)" as the root route$/ do |action|
                   /(routes\.draw do)/,
                   "\\1\nroot :to => '#{action}'"
 end
+
+# Existing users
+
+Given /^(?:I am|I have|I) signed up (?:as|with) "(.*)"$/ do |email|
+  Factory(:user, :email => email)
+end
+
+Given /^a user "([^"]*)" exists without a salt, remember token, or password$/ do |email|
+  user = Factory(:user, :email => email)
+  sql  = "update users set salt = NULL, encrypted_password = NULL, remember_token = NULL where id = #{user.id}"
+  ActiveRecord::Base.connection.update(sql)
+end
+
+# Sign up
+
+When /^I sign up (?:with|as) "(.*)" and "(.*)"$/ do |email, password|
+  visit sign_up_path
+  page.should have_css("input[type='email']")
+
+  fill_in "Email", :with => email
+  fill_in "Password", :with => password
+  click_button "Sign up"
+end
+
+# Sign in
+
+Given /^I sign in$/ do
+  email = Factory.next(:email)
+  steps %{
+    I have signed up with "#{email}"
+    I sign in with "#{email}"
+  }
+end
+
+When /^I sign in (?:with|as) "([^"]*)"$/ do |email|
+  When %{I sign in with "#{email}" and "password"}
+end
+
+When /^I sign in (?:with|as) "([^"]*)" and "([^"]*)"$/ do |email, password|
+  visit sign_in_path
+  page.should have_css("input[type='email']")
+
+  fill_in "Email", :with => email
+  fill_in "Password", :with => password
+  click_button "Sign in"
+end
+
+# Sign out
+
+When "I sign out" do
+  visit "/"
+  click_link "Sign out"
+end
+
+# Reset password
+
+When /^I reset the password for "(.*)"$/ do |email|
+  visit new_password_path
+  page.should have_css("input[type='email']")
+
+  fill_in "Email address", :with => email
+  click_button "Reset password"
+end
+
+Then /^instructions for changing my password are emailed to "(.*)"$/ do |email|
+  page.should have_content("instructions for changing your password")
+
+  user = User.find_by_email!(email)
+  assert !user.confirmation_token.blank?
+  assert !ActionMailer::Base.deliveries.empty?
+  result = ActionMailer::Base.deliveries.any? do |email|
+    email.to      == [user.email] &&
+    email.subject =~ /password/i &&
+    email.body    =~ /#{user.confirmation_token}/
+  end
+  assert result
+end
+
+When /^I follow the password reset link sent to "(.*)"$/ do |email|
+  user = User.find_by_email!(email)
+  visit edit_user_password_path(:user_id => user,
+                                :token   => user.confirmation_token)
+end
+
+When /^I change the password of "(.*)" without token$/ do |email|
+  user = User.find_by_email!(email)
+  visit edit_user_password_path(:user_id => user)
+end
+
+When /^I update my password with "(.*)"$/ do |password|
+  fill_in "Choose password", :with => password
+  click_button "Save this password"
+end
+
+# Flashes
+
+Then /^I am told email or password is bad$/ do
+  page.should have_content("Bad email or password")
+end
+
+Then /^I am told email is unknown$/ do
+  page.should have_content("Unknown email")
+end
+
+Then /^I am told to enter a valid email address$/ do
+  page.should have_content("Must be a valid email address")
+end
+
+Then /^I am told to enter a password$/ do
+  page.should have_content("Password can't be blank")
+end
+
+# Verification
+
+Then /^I should be signed in$/ do
+  visit "/"
+  page.should have_content "Sign out"
+end
+
+Then /^I should be signed out$/ do
+  visit "/"
+  page.should have_content "Sign in"
+end

data/features/step_definitions/engine/braintree_steps.rb

@@ -0,0 +1,24 @@
+Given /^that the credit card "([^"]*)" is invalid$/ do |number|
+  FakeBraintree.registry.failures[number] = { "message" => "Credit card number is invalid.", "errors" => { "customer" => { "errors" => [], "credit-card" => { "errors" => [{ "message" => "Credit card number is invalid.", "code" => 81715, "attribute" => :number }] }}}}
+end
+
+Given /^that the credit card "([^"]*)" should not be honored$/ do |number|
+  FakeBraintree.registry.failures[number] = { "message" => "Do Not Honor", "code" => "2000", "status" => "processor_declined" }
+end
+
+Given /^the "([^"]*)" account is past due$/ do |account_name|
+  account = Account.find_by_name!(account_name)
+  account.update_attribute(:subscription_status, Braintree::Subscription::Status::PastDue)
+end
+
+Given /^the following transactions? exists? for the "([^"]*)" account:$/ do |account_name, table|
+  account = Account.find_by_name!(account_name)
+  subscription = FakeBraintree.registry.subscriptions[account.subscription_token]
+  subscription["transactions"] = []
+  table.hashes.each do |transaction|
+    subscription["transactions"] << FakeBraintree.generate_transaction({ :status => transaction["status"],
+                                                                         :amount => transaction["amount"],
+                                                                         :created_at => DateTime.parse(transaction["created_at"]),
+                                                                         :subscription_id => account.subscription_token })
+  end
+end

data/{lib/generators/saucy/features/templates/step_definitions → features/step_definitions/engine}/cron_steps.rb

@@ -1,9 +1,9 @@
 require 'rake'
 
-module RakeHelpers
+class FakeRake
   include Rake::DSL
 
-  def fake_rake
+  def execute
     old_rake = Rake.application
     rake = Rake::Application.new
     Rake.application = rake
@@ -14,10 +14,8 @@ module RakeHelpers
   end
 end
 
-World(RakeHelpers)
-
 When /^the daily Saucy jobs are processed$/ do
-  fake_rake do |rake|
+  FakeRake.new.execute do |rake|
     Saucy::Engine.load_tasks
     rake['saucy:daily'].invoke
   end

data/features/step_definitions/rails_steps.rb

@@ -28,7 +28,7 @@ When /^I give a more detailed new account message$/ do
       When I go to the sign up page for the "Free" plan
       Then I should see "Please sign up now"
   HERE
-  write_file('features/new_account_message.feature', scenario)
+  write_file('features/customizations.feature', scenario)
 end
 
 When /^I add a custom layout to the accounts index$/ do
@@ -44,7 +44,7 @@ When /^I add a custom layout to the accounts index$/ do
                   /(class .* < Rails::Application)/,
                   "\\1\n#{layout_config}"
 
-  write_file('features/custom_accounts_index_layout.feature', <<-SCENARIO)
+  write_file('features/customizations.feature', <<-SCENARIO)
   Feature: The accounts index should have a custom layout
     Scenario: Custom layout
       Given I am signed up as "email@person.com"
@@ -62,12 +62,30 @@ When /^I add a custom layout to the accounts index$/ do
   SCENARIO
 end
 
-When /^I copy the specs for this project$/ do
-  in_current_dir do
-    FileUtils.cp_r(File.join(PROJECT_ROOT, 'spec'), '.')
-  end
+Then /^all cucumber scenarios should have passed$/ do
+  assert_passing_with "passed"
+  assert_no_partial_output "failed", all_output
+end
+
+When /^I run all cucumber scenarios$/ do
+  run_simple "bundle exec rake cucumber"
+end
+
+When /^I run cucumber scenarios for customizations$/ do
+  run_simple "bundle exec cucumber features/customizations.feature"
+end
+
+Then /^all generators should have run successfully$/ do
+  assert_no_partial_output "Could not find generator", all_output
+end
+
+When /^I generate a new rails application$/ do
+  run_simple "bundle exec rails new testapp --skip-bundle"
+  cd "testapp"
 end
 
-Then /^at least one example should have run$/ do
-  steps %{Then the output should match /[1-9]0* examples/}
+Then /^pause the page$/ do
+  puts
+  puts "Press enter to continue"
+  $stdin.gets
 end

data/features/step_definitions/saucy_steps.rb

@@ -1,4 +1,7 @@
 When /^I bootstrap the application for saucy$/ do
+  run_simple "rails generate saucy:install"
+  run_simple "rails generate saucy:features"
+  run_simple "bundle exec rake db:migrate db:test:prepare"
 end
 
 When /^I copy the locked Gemfile from this project$/ do
@@ -6,3 +9,5 @@ When /^I copy the locked Gemfile from this project$/ do
     FileUtils.cp(File.join(PROJECT_ROOT, 'Gemfile.lock'), 'Gemfile.lock')
   end
 end
+
+

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,253 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select or option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+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 "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field should have the error "([^"]*)"$/ do |field, error_message|
+  element = find_field(field)
+  classes = element.find(:xpath, '..')[:class].split(' ')
+
+  form_for_input = element.find(:xpath, 'ancestor::form[1]')
+  using_formtastic = form_for_input[:class].include?('formtastic')
+  error_class = using_formtastic ? 'error' : 'field_with_errors'
+
+  if classes.respond_to? :should
+    classes.should include(error_class)
+  else
+    assert classes.include?(error_class)
+  end
+
+  if page.respond_to?(:should)
+    if using_formtastic
+      error_paragraph = element.find(:xpath, '../*[@class="inline-errors"][1]')
+      error_paragraph.should have_content(error_message)
+    else
+      page.should have_content("#{field.titlecase} #{error_message}")
+    end
+  else
+    if using_formtastic
+      error_paragraph = element.find(:xpath, '../*[@class="inline-errors"][1]')
+      assert error_paragraph.has_content?(error_message)
+    else
+      assert page.has_content?("#{field.titlecase} #{error_message}")
+    end
+  end
+end
+
+Then /^the "([^"]*)" field should have no error$/ do |field|
+  element = find_field(field)
+  classes = element.find(:xpath, '..')[:class].split(' ')
+  if classes.respond_to? :should
+    classes.should_not include('field_with_errors')
+    classes.should_not include('error')
+  else
+    assert !classes.include?('field_with_errors')
+    assert !classes.include?('error')
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
+  
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end