devise 3.2.0 → 3.3.0

data/test/routes_test.rb

@@ -4,107 +4,107 @@ ExpectedRoutingError = Devise.rails4? ? MiniTest::Assertion : ActionController::
 
 class DefaultRoutingTest < ActionController::TestCase
   test 'map new user session' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'new'}, {:path => 'users/sign_in', :method => :get})
+    assert_recognizes({controller: 'devise/sessions', action: 'new'}, {path: 'users/sign_in', method: :get})
     assert_named_route "/users/sign_in", :new_user_session_path
   end
 
   test 'map create user session' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'create'}, {:path => 'users/sign_in', :method => :post})
+    assert_recognizes({controller: 'devise/sessions', action: 'create'}, {path: 'users/sign_in', method: :post})
     assert_named_route "/users/sign_in", :user_session_path
   end
 
   test 'map destroy user session' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => 'users/sign_out', :method => :get})
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: 'users/sign_out', method: :get})
     assert_named_route "/users/sign_out", :destroy_user_session_path
   end
 
   test 'map new user confirmation' do
-    assert_recognizes({:controller => 'devise/confirmations', :action => 'new'}, 'users/confirmation/new')
+    assert_recognizes({controller: 'devise/confirmations', action: 'new'}, 'users/confirmation/new')
     assert_named_route "/users/confirmation/new", :new_user_confirmation_path
   end
 
   test 'map create user confirmation' do
-    assert_recognizes({:controller => 'devise/confirmations', :action => 'create'}, {:path => 'users/confirmation', :method => :post})
+    assert_recognizes({controller: 'devise/confirmations', action: 'create'}, {path: 'users/confirmation', method: :post})
     assert_named_route "/users/confirmation", :user_confirmation_path
   end
 
   test 'map show user confirmation' do
-    assert_recognizes({:controller => 'devise/confirmations', :action => 'show'}, {:path => 'users/confirmation', :method => :get})
+    assert_recognizes({controller: 'devise/confirmations', action: 'show'}, {path: 'users/confirmation', method: :get})
   end
 
   test 'map new user password' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'new'}, 'users/password/new')
+    assert_recognizes({controller: 'devise/passwords', action: 'new'}, 'users/password/new')
     assert_named_route "/users/password/new", :new_user_password_path
   end
 
   test 'map create user password' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'create'}, {:path => 'users/password', :method => :post})
+    assert_recognizes({controller: 'devise/passwords', action: 'create'}, {path: 'users/password', method: :post})
     assert_named_route "/users/password", :user_password_path
   end
 
   test 'map edit user password' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'edit'}, 'users/password/edit')
+    assert_recognizes({controller: 'devise/passwords', action: 'edit'}, 'users/password/edit')
     assert_named_route "/users/password/edit", :edit_user_password_path
   end
 
   test 'map update user password' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'update'}, {:path => 'users/password', :method => :put})
+    assert_recognizes({controller: 'devise/passwords', action: 'update'}, {path: 'users/password', method: :put})
   end
 
   test 'map new user unlock' do
-    assert_recognizes({:controller => 'devise/unlocks', :action => 'new'}, 'users/unlock/new')
+    assert_recognizes({controller: 'devise/unlocks', action: 'new'}, 'users/unlock/new')
     assert_named_route "/users/unlock/new", :new_user_unlock_path
   end
 
   test 'map create user unlock' do
-    assert_recognizes({:controller => 'devise/unlocks', :action => 'create'}, {:path => 'users/unlock', :method => :post})
+    assert_recognizes({controller: 'devise/unlocks', action: 'create'}, {path: 'users/unlock', method: :post})
     assert_named_route "/users/unlock", :user_unlock_path
   end
 
   test 'map show user unlock' do
-    assert_recognizes({:controller => 'devise/unlocks', :action => 'show'}, {:path => 'users/unlock', :method => :get})
+    assert_recognizes({controller: 'devise/unlocks', action: 'show'}, {path: 'users/unlock', method: :get})
   end
 
   test 'map new user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, 'users/sign_up')
+    assert_recognizes({controller: 'devise/registrations', action: 'new'}, 'users/sign_up')
     assert_named_route "/users/sign_up", :new_user_registration_path
   end
 
   test 'map create user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'create'}, {:path => 'users', :method => :post})
+    assert_recognizes({controller: 'devise/registrations', action: 'create'}, {path: 'users', method: :post})
     assert_named_route "/users", :user_registration_path
   end
 
   test 'map edit user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'edit'}, {:path => 'users/edit', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'edit'}, {path: 'users/edit', method: :get})
     assert_named_route "/users/edit", :edit_user_registration_path
   end
 
   test 'map update user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'update'}, {:path => 'users', :method => :put})
+    assert_recognizes({controller: 'devise/registrations', action: 'update'}, {path: 'users', method: :put})
   end
 
   test 'map destroy user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'destroy'}, {:path => 'users', :method => :delete})
+    assert_recognizes({controller: 'devise/registrations', action: 'destroy'}, {path: 'users', method: :delete})
   end
 
   test 'map cancel user registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'cancel'}, {:path => 'users/cancel', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'cancel'}, {path: 'users/cancel', method: :get})
     assert_named_route "/users/cancel", :cancel_user_registration_path
   end
 
   test 'map omniauth callbacks' do
-    assert_recognizes({:controller => 'users/omniauth_callbacks', :action => 'facebook'}, {:path => 'users/auth/facebook/callback', :method => :get})
-    assert_recognizes({:controller => 'users/omniauth_callbacks', :action => 'facebook'}, {:path => 'users/auth/facebook/callback', :method => :post})
+    assert_recognizes({controller: 'users/omniauth_callbacks', action: 'facebook'}, {path: 'users/auth/facebook/callback', method: :get})
+    assert_recognizes({controller: 'users/omniauth_callbacks', action: 'facebook'}, {path: 'users/auth/facebook/callback', method: :post})
     assert_named_route "/users/auth/facebook/callback", :user_omniauth_callback_path, :facebook
 
     # named open_id
-    assert_recognizes({:controller => 'users/omniauth_callbacks', :action => 'google'}, {:path => 'users/auth/google/callback', :method => :get})
-    assert_recognizes({:controller => 'users/omniauth_callbacks', :action => 'google'}, {:path => 'users/auth/google/callback', :method => :post})
+    assert_recognizes({controller: 'users/omniauth_callbacks', action: 'google'}, {path: 'users/auth/google/callback', method: :get})
+    assert_recognizes({controller: 'users/omniauth_callbacks', action: 'google'}, {path: 'users/auth/google/callback', method: :post})
     assert_named_route "/users/auth/google/callback", :user_omniauth_callback_path, :google
 
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'ysers/omniauth_callbacks', :action => 'twitter'}, {:path => 'users/auth/twitter/callback', :method => :get})
+      assert_recognizes({controller: 'ysers/omniauth_callbacks', action: 'twitter'}, {path: 'users/auth/twitter/callback', method: :get})
     end
   end
 
@@ -117,134 +117,148 @@ end
 
 class CustomizedRoutingTest < ActionController::TestCase
   test 'map admin with :path option' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => 'admin_area/sign_up', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: 'admin_area/sign_up', method: :get})
   end
 
   test 'map admin with :controllers option' do
-    assert_recognizes({:controller => 'admins/sessions', :action => 'new'}, {:path => 'admin_area/sign_in', :method => :get})
+    assert_recognizes({controller: 'admins/sessions', action: 'new'}, {path: 'admin_area/sign_in', method: :get})
   end
 
   test 'does not map admin password' do
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/passwords', :action => 'new'}, 'admin_area/password/new')
+      assert_recognizes({controller: 'devise/passwords', action: 'new'}, 'admin_area/password/new')
     end
   end
 
   test 'subdomain admin' do
-    assert_recognizes({"host"=>"sub.example.com", :controller => 'devise/sessions', :action => 'new'}, {:host => "sub.example.com", :path => '/sub_admin/sign_in', :method => :get})
+    assert_recognizes({"host"=>"sub.example.com", controller: 'devise/sessions', action: 'new'}, {host: "sub.example.com", path: '/sub_admin/sign_in', method: :get})
   end
 
   test 'does only map reader password' do
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/sessions', :action => 'new'}, 'reader/sessions/new')
+      assert_recognizes({controller: 'devise/sessions', action: 'new'}, 'reader/sessions/new')
     end
-    assert_recognizes({:controller => 'devise/passwords', :action => 'new'}, 'reader/password/new')
+    assert_recognizes({controller: 'devise/passwords', action: 'new'}, 'reader/password/new')
   end
 
   test 'map account with custom path name for session sign in' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'new', :locale => 'en'}, '/en/accounts/login')
+    assert_recognizes({controller: 'devise/sessions', action: 'new', locale: 'en'}, '/en/accounts/login')
   end
 
   test 'map account with custom path name for session sign out' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy', :locale => 'en'}, '/en/accounts/logout')
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy', locale: 'en'}, '/en/accounts/logout')
   end
 
   test 'map account with custom path name for password' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'new', :locale => 'en'}, '/en/accounts/secret/new')
+    assert_recognizes({controller: 'devise/passwords', action: 'new', locale: 'en'}, '/en/accounts/secret/new')
   end
 
   test 'map account with custom path name for registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new', :locale => 'en'}, '/en/accounts/management/register')
+    assert_recognizes({controller: 'devise/registrations', action: 'new', locale: 'en'}, '/en/accounts/management/register')
+  end
+
+  test 'map account with custom path name for edit registration' do
+    assert_recognizes({controller: 'devise/registrations', action: 'edit', locale: 'en'}, '/en/accounts/management/edit/profile')
   end
 
   test 'map account with custom path name for cancel registration' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'cancel', :locale => 'en'}, '/en/accounts/management/giveup')
+    assert_recognizes({controller: 'devise/registrations', action: 'cancel', locale: 'en'}, '/en/accounts/management/giveup')
   end
 
   test 'map deletes with :sign_out_via option' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/deletes/sign_out', :method => :delete})
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/deletes/sign_out', method: :delete})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/deletes/sign_out', :method => :get})
+      assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/deletes/sign_out', method: :get})
     end
   end
 
   test 'map posts with :sign_out_via option' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/posts/sign_out', :method => :post})
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/posts/sign_out', method: :post})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/posts/sign_out', :method => :get})
+      assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/posts/sign_out', method: :get})
     end
   end
 
   test 'map delete_or_posts with :sign_out_via option' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/delete_or_posts/sign_out', :method => :post})
-    assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/delete_or_posts/sign_out', :method => :delete})
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/delete_or_posts/sign_out', method: :post})
+    assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/delete_or_posts/sign_out', method: :delete})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/sessions', :action => 'destroy'}, {:path => '/sign_out_via/delete_or_posts/sign_out', :method => :get})
+      assert_recognizes({controller: 'devise/sessions', action: 'destroy'}, {path: '/sign_out_via/delete_or_posts/sign_out', method: :get})
     end
   end
 
   test 'map with constraints defined in hash' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => 'http://192.168.1.100/headquarters/sign_up', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: 'http://192.168.1.100/headquarters/sign_up', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => 'http://10.0.0.100/headquarters/sign_up', :method => :get})
+      assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: 'http://10.0.0.100/headquarters/sign_up', method: :get})
     end
   end
 
   test 'map with constraints defined in block' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => 'http://192.168.1.100/homebase/sign_up', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: 'http://192.168.1.100/homebase/sign_up', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => 'http://10.0.0.100//homebase/sign_up', :method => :get})
+      assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: 'http://10.0.0.100//homebase/sign_up', method: :get})
     end
   end
 
   test 'map with format false for sessions' do
-    assert_recognizes({:controller => 'devise/sessions', :action => 'new'}, {:path => '/htmlonly_admin/sign_in', :method => :get})
+    assert_recognizes({controller: 'devise/sessions', action: 'new'}, {path: '/htmlonly_admin/sign_in', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/sessions', :action => 'new'}, {:path => '/htmlonly_admin/sign_in.xml', :method => :get})
+      assert_recognizes({controller: 'devise/sessions', action: 'new'}, {path: '/htmlonly_admin/sign_in.xml', method: :get})
     end
   end
 
   test 'map with format false for passwords' do
-    assert_recognizes({:controller => 'devise/passwords', :action => 'create'}, {:path => '/htmlonly_admin/password', :method => :post})
+    assert_recognizes({controller: 'devise/passwords', action: 'create'}, {path: '/htmlonly_admin/password', method: :post})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/passwords', :action => 'create'}, {:path => '/htmlonly_admin/password.xml', :method => :post})
+      assert_recognizes({controller: 'devise/passwords', action: 'create'}, {path: '/htmlonly_admin/password.xml', method: :post})
     end
   end
 
   test 'map with format false for registrations' do
-    assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => '/htmlonly_admin/sign_up', :method => :get})
+    assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: '/htmlonly_admin/sign_up', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/registrations', :action => 'new'}, {:path => '/htmlonly_admin/sign_up.xml', :method => :get})
+      assert_recognizes({controller: 'devise/registrations', action: 'new'}, {path: '/htmlonly_admin/sign_up.xml', method: :get})
     end
   end
 
   test 'map with format false for confirmations' do
-    assert_recognizes({:controller => 'devise/confirmations', :action => 'show'}, {:path => '/htmlonly_users/confirmation', :method => :get})
+    assert_recognizes({controller: 'devise/confirmations', action: 'show'}, {path: '/htmlonly_users/confirmation', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/confirmations', :action => 'show'}, {:path => '/htmlonly_users/confirmation.xml', :method => :get})
+      assert_recognizes({controller: 'devise/confirmations', action: 'show'}, {path: '/htmlonly_users/confirmation.xml', method: :get})
     end
   end
 
   test 'map with format false for unlocks' do
-    assert_recognizes({:controller => 'devise/unlocks', :action => 'show'}, {:path => '/htmlonly_users/unlock', :method => :get})
+    assert_recognizes({controller: 'devise/unlocks', action: 'show'}, {path: '/htmlonly_users/unlock', method: :get})
     assert_raise ExpectedRoutingError do
-      assert_recognizes({:controller => 'devise/unlocks', :action => 'show'}, {:path => '/htmlonly_users/unlock.xml', :method => :get})
+      assert_recognizes({controller: 'devise/unlocks', action: 'show'}, {path: '/htmlonly_users/unlock.xml', method: :get})
     end
   end
 
   test 'map with format false is not permanent' do
     assert_equal "/set.xml", @routes.url_helpers.set_path(:xml)
   end
+
+  test 'checks if mapping has proper configuration for omniauth callback' do
+    e = assert_raise ArgumentError do
+      routes = ActionDispatch::Routing::RouteSet.new
+      routes.draw do
+        devise_for :not_omniauthable, class_name: 'Admin', controllers: {omniauth_callbacks: "users/omniauth_callbacks"}
+      end
+    end
+    assert_match "Mapping omniauth_callbacks on a resource that is not omniauthable", e.message
+  end
 end
 
 class ScopedRoutingTest < ActionController::TestCase
   test 'map publisher account' do
-    assert_recognizes({:controller => 'publisher/registrations', :action => 'new'}, {:path => '/publisher/accounts/sign_up', :method => :get})
+    assert_recognizes({controller: 'publisher/registrations', action: 'new'}, {path: '/publisher/accounts/sign_up', method: :get})
     assert_equal '/publisher/accounts/sign_up', @routes.url_helpers.new_publisher_account_registration_path
   end
 
   test 'map publisher account merges path names' do
-    assert_recognizes({:controller => 'publisher/sessions', :action => 'new'}, {:path => '/publisher/accounts/get_in', :method => :get})
+    assert_recognizes({controller: 'publisher/sessions', action: 'new'}, {path: '/publisher/accounts/get_in', method: :get})
     assert_equal '/publisher/accounts/get_in', @routes.url_helpers.new_publisher_account_session_path
   end
 end

data/test/support/action_controller/record_identifier.rb

@@ -0,0 +1,10 @@
+# Since webrat uses ActionController::RecordIdentifier class that was moved to
+# ActionView namespace in Rails 4.1+
+
+unless defined?(ActionController::RecordIdentifier)
+  require 'action_view/record_identifier'
+
+  module ActionController
+    RecordIdentifier = ActionView::RecordIdentifier
+  end
+end

data/test/support/assertions.rb

@@ -9,10 +9,9 @@ class ActiveSupport::TestCase
     assert assertion.blank?
   end
 
-  def assert_not_blank(assertion)
-    assert !assertion.blank?
+  def assert_present(assertion)
+    assert assertion.present?
   end
-  alias :assert_present :assert_not_blank
 
   def assert_email_sent(address = nil, &block)
     assert_difference('ActionMailer::Base.deliveries.size', &block)

data/test/support/helpers.rb

@@ -23,10 +23,10 @@ class ActiveSupport::TestCase
   end
 
   def valid_attributes(attributes={})
-    { :username => "usertest",
-      :email => generate_unique_email,
-      :password => '12345678',
-      :password_confirmation => '12345678' }.update(attributes)
+    { username: "usertest",
+      email: generate_unique_email,
+      password: '12345678',
+      password_confirmation: '12345678' }.update(attributes)
   end
 
   def new_user(attributes={})

data/test/support/integration.rb

@@ -8,11 +8,11 @@ class ActionDispatch::IntegrationTest
   def create_user(options={})
     @user ||= begin
       user = User.create!(
-        :username => 'usertest',
-        :email => options[:email] || 'user@test.com',
-        :password => options[:password] || '12345678',
-        :password_confirmation => options[:password] || '12345678',
-        :created_at => Time.now.utc
+        username: 'usertest',
+        email: options[:email] || 'user@test.com',
+        password: options[:password] || '12345678',
+        password_confirmation: options[:password] || '12345678',
+        created_at: Time.now.utc
       )
       user.update_attribute(:confirmation_sent_at, options[:confirmation_sent_at]) if options[:confirmation_sent_at]
       user.confirm! unless options[:confirm] == false
@@ -24,9 +24,9 @@ class ActionDispatch::IntegrationTest
   def create_admin(options={})
     @admin ||= begin
       admin = Admin.create!(
-        :email => options[:email] || 'admin@test.com',
-        :password => '123456', :password_confirmation => '123456',
-        :active => options[:active]
+        email: options[:email] || 'admin@test.com',
+        password: '123456', password_confirmation: '123456',
+        active: options[:active]
       )
       admin.confirm! unless options[:confirm] == false
       admin
@@ -36,21 +36,21 @@ class ActionDispatch::IntegrationTest
   def sign_in_as_user(options={}, &block)
     user = create_user(options)
     visit_with_option options[:visit], new_user_session_path
-    fill_in 'email', :with => options[:email] || 'user@test.com'
-    fill_in 'password', :with => options[:password] || '12345678'
+    fill_in 'email', with: options[:email] || 'user@test.com'
+    fill_in 'password', with: options[:password] || '12345678'
     check 'remember me' if options[:remember_me] == true
     yield if block_given?
-    click_button 'Sign In'
+    click_button 'Log In'
     user
   end
 
   def sign_in_as_admin(options={}, &block)
     admin = create_admin(options)
     visit_with_option options[:visit], new_admin_session_path
-    fill_in 'email', :with => 'admin@test.com'
-    fill_in 'password', :with => '123456'
+    fill_in 'email', with: 'admin@test.com'
+    fill_in 'password', with: '123456'
     yield if block_given?
-    click_button 'Sign In'
+    click_button 'Log In'
     admin
   end
 

data/test/support/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: devise-test-suite
+      hosts:
+        - localhost:<%= ENV['MONGODB_PORT'] || '27017' %>

data/test/test_helper.rb

@@ -4,13 +4,6 @@ DEVISE_ORM = (ENV["DEVISE_ORM"] || :active_record).to_sym
 $:.unshift File.dirname(__FILE__)
 puts "\n==> Devise.orm = #{DEVISE_ORM.inspect}"
 
-module Devise
-  # Detection for minor differences between Rails 3.2 and 4 in tests.
-  def self.rails4?
-    Rails.version.start_with? '4'
-  end
-end
-
 require "rails_app/config/environment"
 require "rails/test_help"
 require "orm/#{DEVISE_ORM}"
@@ -24,6 +17,8 @@ Webrat.configure do |config|
   config.open_error_files = false
 end
 
+OmniAuth.config.logger = Logger.new('/dev/null')
+
 # Add support to load paths so we can overwrite broken webrat setup
 $:.unshift File.expand_path('../support', __FILE__)
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/test/test_helpers_test.rb

@@ -4,12 +4,6 @@ class TestHelpersTest < ActionController::TestCase
   tests UsersController
   include Devise::TestHelpers
 
-  class CustomFailureApp < Devise::FailureApp
-    def redirect
-      self.status = 306
-    end
-  end
-
   test "redirects if attempting to access a page unauthenticated" do
     get :index
     assert_redirected_to new_user_session_path
@@ -17,7 +11,7 @@ class TestHelpersTest < ActionController::TestCase
   end
 
   test "redirects if attempting to access a page with an unconfirmed account" do
-    swap Devise, :allow_unconfirmed_access_for => 0 do
+    swap Devise, allow_unconfirmed_access_for: 0.days do
       user = create_user
       assert !user.active_for_authentication?
 
@@ -28,12 +22,12 @@ class TestHelpersTest < ActionController::TestCase
   end
 
   test "returns nil if accessing current_user with an unconfirmed account" do
-    swap Devise, :allow_unconfirmed_access_for => 0 do
+    swap Devise, allow_unconfirmed_access_for: 0.days do
       user = create_user
       assert !user.active_for_authentication?
 
       sign_in user
-      get :accept, :id => user
+      get :accept, id: user
       assert_nil assigns(:current_user)
     end
   end
@@ -72,12 +66,30 @@ class TestHelpersTest < ActionController::TestCase
   end
 
   test "respects custom failure app" do
-    begin
-      Devise.warden_config.failure_app = CustomFailureApp
+    custom_failure_app = Class.new(Devise::FailureApp) do
+      def redirect
+        self.status = 306
+      end
+    end
+
+    swap Devise.warden_config, failure_app: custom_failure_app do
       get :index
       assert_response 306
-    ensure
-      Devise.warden_config.failure_app = Devise::FailureApp
+    end
+  end
+
+  test "passes given headers from the failure app to the response" do
+    custom_failure_app = Class.new(Devise::FailureApp) do
+      def respond
+        self.status = 401
+        self.response.headers["CUSTOMHEADER"] = 1
+      end
+    end
+
+    swap Devise.warden_config, failure_app: custom_failure_app do
+      sign_in create_user
+      get :index
+      assert_equal 1, @response.headers["CUSTOMHEADER"]
     end
   end
 
@@ -148,26 +160,4 @@ class TestHelpersTest < ActionController::TestCase
     get :index
     assert_match /User ##{second_user.id}/, @response.body
   end
-
-
-  test "passes  given headers from the failure app to the response" do
-
-    begin
-      old_failure_app = Devise.warden_config[:failure_app]
-      class CustomTestFailureApp < Devise::FailureApp
-        def respond
-          self.status = 401
-          self.response.headers["CUSTOMHEADER"] = 1
-        end
-      end
-      Devise.warden_config[:failure_app] = CustomTestFailureApp
-      user = create_user
-      sign_in user
-      get :index
-      assert_equal 1, @response.headers["CUSTOMHEADER"]
-    ensure
-      Devise.warden_config[:failure_app] = old_failure_app
-    end
-  end
-
 end

data/test/test_models.rb

@@ -1,20 +1,27 @@
 class Configurable < User
   devise :database_authenticatable, :confirmable, :rememberable, :timeoutable, :lockable,
-         :stretches => 15, :pepper => 'abcdef', :allow_unconfirmed_access_for => 5.days,
-         :remember_for => 7.days, :timeout_in => 15.minutes, :unlock_in => 10.days
+         stretches: 15, pepper: 'abcdef', allow_unconfirmed_access_for: 5.days,
+         remember_for: 7.days, timeout_in: 15.minutes, unlock_in: 10.days
 end
 
 class WithValidation < Admin
-  devise :database_authenticatable, :validatable, :password_length => 2..6
+  devise :database_authenticatable, :validatable, password_length: 2..6
 end
 
 class UserWithValidation < User
   validates_presence_of :username
 end
 
+class UserWithCustomEncryption < User
+  protected
+  def password_digest(password)
+    password.reverse
+  end
+end
+
 class UserWithVirtualAttributes < User
-  devise :case_insensitive_keys => [ :email, :email_confirmation ]
-  validates :email, :presence => true, :confirmation => {:on => :create}
+  devise case_insensitive_keys: [ :email, :email_confirmation ]
+  validates :email, presence: true, confirmation: {on: :create}
 end
 
 class Several < Admin