clearance 0.8.4 → 0.8.5

data/test/rails_root/config/environment.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'boot')
+require 'digest/md5'
+
+Rails::Initializer.run do |config|
+  config.load_paths += Dir.glob(File.join(RAILS_ROOT, 'vendor', 'gems', '*', 'lib'))
+  config.time_zone = 'Eastern Time (US & Canada)'
+  config.action_controller.session = {
+    :session_key => "_clearance_session",
+    :secret      => ['clearance', 'random', 'words', 'here'].map {|k| Digest::MD5.hexdigest(k) }.join
+  }
+
+  config.gem "justinfrench-formtastic", 
+    :lib     => 'formtastic', 
+    :source  => 'http://gems.github.com'
+
+  config.action_mailer.default_url_options = { :host => 'localhost:3000' }
+end

data/test/rails_root/config/environments/development.rb

@@ -0,0 +1,19 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# In the development environment your application's code is reloaded on
+# every request.  This slows down response time but is perfect for development
+# since you don't have to restart the webserver when you make code changes.
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.debug_rjs                         = true
+
+# Don't care if the mailer can't send
+config.action_mailer.raise_delivery_errors = false
+
+HOST = "localhost"

data/test/rails_root/config/environments/production.rb

@@ -0,0 +1 @@
+HOST = "http://example.com"

data/test/rails_root/config/environments/test.rb

@@ -0,0 +1,36 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+config.gem 'shoulda',
+  :source  => "http://gemcutter.org",
+  :version => '>= 2.9.1'
+config.gem 'factory_girl',
+  :source  => "http://gemcutter.org",
+  :version => '>= 1.2.3'
+
+config.gem 'cucumber-rails',
+  :lib     => false,
+  :version => '>= 0.2.2'
+config.gem 'webrat',
+  :lib     => false,
+  :version => '>= 0.6.0'

data/test/rails_root/config/initializers/clearance.rb

@@ -0,0 +1,3 @@
+Clearance.configure do |config|
+  config.mailer_sender = 'donotreply@example.com'
+end

data/test/rails_root/config/initializers/clearance_loader.rb

@@ -0,0 +1,8 @@
+# This simulates loading the clearance gem, but without relying on
+# vendor/gems
+
+clearance_path = File.join(File.dirname(__FILE__), *%w(.. .. .. ..))
+clearance_lib_path = File.join(clearance_path, "lib")
+
+$LOAD_PATH.unshift(clearance_lib_path)
+load File.join(clearance_path, 'rails', 'init.rb')

data/test/rails_root/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/test/rails_root/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/test/rails_root/config/initializers/requires.rb

@@ -0,0 +1,13 @@
+Dir[File.join(RAILS_ROOT, 'lib', 'extensions', '*.rb')].each do |f|
+  require f
+end
+
+Dir[File.join(RAILS_ROOT, 'lib', '*.rb')].each do |f|
+  require f
+end
+
+# Rails 2 doesn't like mocks
+
+Dir[File.join(RAILS_ROOT, 'test', 'mocks', RAILS_ENV, '*.rb')].each do |f|
+  require f
+end

data/test/rails_root/config/initializers/time_formats.rb

@@ -0,0 +1,4 @@
+# Example time formats
+{ :short_date => "%x", :long_date => "%a, %b %d, %Y" }.each do |k, v|
+  ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS.update(k => v)
+end

data/test/rails_root/config/routes.rb

@@ -0,0 +1,6 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resource :account
+  map.root :controller => 'accounts', :action => 'edit'
+
+  Clearance::Routes.draw(map)
+end

data/test/rails_root/db/migrate/20100120045223_clearance_create_users.rb

@@ -0,0 +1,21 @@
+class ClearanceCreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table(:users) do |t|
+      t.string   :email
+      t.string   :encrypted_password, :limit => 128
+      t.string   :salt,               :limit => 128
+      t.string   :confirmation_token, :limit => 128
+      t.string   :remember_token,     :limit => 128
+      t.boolean  :email_confirmed, :default => false, :null => false
+      t.timestamps
+    end
+
+    add_index :users, [:id, :confirmation_token]
+    add_index :users, :email
+    add_index :users, :remember_token
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

data/test/rails_root/features/step_definitions/clearance_steps.rb

@@ -0,0 +1,122 @@
+# General
+
+Then /^I should see error messages$/ do
+  assert_match /error(s)? prohibited/m, response.body
+end
+
+# Database
+
+Given /^no user exists with an email of "(.*)"$/ do |email|
+  assert_nil User.find_by_email(email)
+end
+
+Given /^I signed up with "(.*)\/(.*)"$/ do |email, password|
+  user = Factory :user,
+    :email                 => email,
+    :password              => password,
+    :password_confirmation => password
+end 
+
+Given /^I am signed up and confirmed as "(.*)\/(.*)"$/ do |email, password|
+  user = Factory :email_confirmed_user,
+    :email                 => email,
+    :password              => password,
+    :password_confirmation => password
+end
+
+# Session
+
+Then /^I should be signed in$/ do
+  assert controller.signed_in?
+end
+
+Then /^I should be signed out$/ do
+  assert ! controller.signed_in?
+end
+
+When /^session is cleared$/ do
+  request.reset_session
+  controller.instance_variable_set(:@_current_user, nil)
+end
+
+Given /^I have signed in with "(.*)\/(.*)"$/ do |email, password|
+  Given %{I am signed up and confirmed as "#{email}/#{password}"}
+  And %{I sign in as "#{email}/#{password}"}
+end
+
+# Emails
+
+Then /^a confirmation message should be sent to "(.*)"$/ do |email|
+  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 =~ /confirm/i &&
+    email.body =~ /#{user.confirmation_token}/
+  end
+  assert result
+end
+
+When /^I follow the confirmation link sent to "(.*)"$/ do |email|
+  user = User.find_by_email(email)
+  visit new_user_confirmation_path(:user_id => user,
+                                   :token   => user.confirmation_token)
+end
+
+Then /^a password reset message should be sent to "(.*)"$/ do |email|
+  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 try to change the password of "(.*)" without token$/ do |email|
+  user = User.find_by_email(email)
+  visit edit_user_password_path(:user_id => user)
+end
+
+Then /^I should be forbidden$/ do
+  assert_response :forbidden
+end
+
+# Actions
+
+When /^I sign in as "(.*)\/(.*)"$/ do |email, password|
+  When %{I go to the sign in page}
+  And %{I fill in "Email" with "#{email}"}
+  And %{I fill in "Password" with "#{password}"}
+  And %{I press "Sign In"}
+end
+
+When /^I sign out$/ do
+  visit '/sign_out'
+end
+
+When /^I request password reset link to be sent to "(.*)"$/ do |email|
+  When %{I go to the password reset request page}
+  And %{I fill in "Email address" with "#{email}"}
+  And %{I press "Reset password"}
+end
+
+When /^I update my password with "(.*)\/(.*)"$/ do |password, confirmation|
+  And %{I fill in "Choose password" with "#{password}"}
+  And %{I fill in "Confirm password" with "#{confirmation}"}
+  And %{I press "Save this password"}
+end
+
+When /^I return next time$/ do
+  When %{session is cleared}
+  And %{I go to the homepage}
+end

data/test/rails_root/features/step_definitions/factory_girl_steps.rb

@@ -0,0 +1,5 @@
+Factory.factories.each do |name, factory|
+  Given /^an? #{name} exists with an? (.*) of "([^"]*)"$/ do |attr, value|
+    Factory(name, attr.gsub(' ', '_') => value)
+  end
+end

data/test/rails_root/features/step_definitions/web_steps.rb

@@ -0,0 +1,259 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a
+# newer version of cucumber-rails. Consider adding your own code to a new file
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+
+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)
+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 )follow "([^\"]*)" within "([^\"]*)"$/ do |link, parent|
+  click_link_within(parent, 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 og 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
+
+# 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
+
+# Adds support for validates_attachment_content_type. Without the mime-type getting
+# passed to attach_file() you will get a "Photo file is not one of the allowed file types."
+# error message
+When /^(?:|I )attach the file "([^\"]*)" to "([^\"]*)"$/ do |path, field|
+  type = path.split(".")[1]
+
+  case type
+  when "jpg"
+    type = "image/jpg"
+  when "jpeg"
+    type = "image/jpeg"
+  when "png"
+    type = "image/png"
+  when "gif"
+    type = "image/gif"
+  end
+
+  attach_file(field, path, type)
+end
+
+Then /^(?:|I )should see "([^\"]*)"$/ do |text|
+  if defined?(Spec::Rails::Matchers)
+    response.should contain(text)
+  else
+    assert_contain text
+  end
+end
+
+Then /^(?:|I )should see "([^\"]*)" within "([^\"]*)"$/ do |text, selector|
+  within(selector) do |content|
+    if defined?(Spec::Rails::Matchers)
+      content.should contain(text)
+    else
+      assert content.include?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+  if defined?(Spec::Rails::Matchers)
+    response.should contain(regexp)
+  else
+    assert_contain regexp
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/ within "([^\"]*)"$/ do |regexp, selector|
+  within(selector) do |content|
+    regexp = Regexp.new(regexp)
+    if defined?(Spec::Rails::Matchers)
+      content.should contain(regexp)
+    else
+      assert content =~ regexp
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)"$/ do |text|
+  if defined?(Spec::Rails::Matchers)
+    response.should_not contain(text)
+  else
+    assert_not_contain text
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)" within "([^\"]*)"$/ do |text, selector|
+  within(selector) do |content|
+    if defined?(Spec::Rails::Matchers)
+        content.should_not contain(text)
+    else
+        assert !content.include?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+  if defined?(Spec::Rails::Matchers)
+    response.should_not contain(regexp)
+  else
+    assert_not_contain regexp
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/ within "([^\"]*)"$/ do |regexp, selector|
+  within(selector) do |content|
+    regexp = Regexp.new(regexp)
+    if defined?(Spec::Rails::Matchers)
+      content.should_not contain(regexp)
+    else
+      assert content !~ regexp
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(field).value.should =~ /#{value}/
+  else
+    assert_match(/#{value}/, field_labeled(field).value)
+  end
+end
+
+Then /^the "([^\"]*)" field should not contain "([^\"]*)"$/ do |field, value|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(field).value.should_not =~ /#{value}/
+  else
+    assert_no_match(/#{value}/, field_labeled(field).value)
+  end
+end
+
+Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(label).should be_checked
+  else
+    assert field_labeled(label).checked?
+  end
+end
+
+Then /^the "([^\"]*)" checkbox should not be checked$/ do |label|
+  if defined?(Spec::Rails::Matchers)
+    field_labeled(label).should_not be_checked
+  else
+    assert !field_labeled(label).checked?
+  end
+end
+
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  if defined?(Spec::Rails::Matchers)
+    URI.parse(current_url).path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), URI.parse(current_url).path
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end