devise 1.0.10 → 1.1.0

data/test/models/lockable_test.rb

@@ -1,39 +1,43 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class LockableTest < ActiveSupport::TestCase
-
   def setup
     setup_mailer
   end
 
-  test "should increment failed attempts on unsuccessful authentication" do
+  test "should respect maximum attempts configuration" do
     user = create_user
-    assert_equal 0, user.failed_attempts
-    authenticated_user = User.authenticate(:email => user.email, :password => "anotherpassword")
-    assert_equal 1, user.reload.failed_attempts
+    user.confirm!
+    swap Devise, :maximum_attempts => 2 do
+      3.times { user.valid_for_authentication?{ false } }
+      assert user.reload.access_locked?
+    end
   end
 
-  test "should lock account base on maximum_attempts" do
+  test "should clear failed_attempts on successfull validation" do
     user = create_user
-    attempts = Devise.maximum_attempts + 1
-    attempts.times { authenticated_user = User.authenticate(:email => user.email, :password => "anotherpassword") }
-    assert user.reload.access_locked?
+    user.confirm!
+    user.valid_for_authentication?{ false }
+    assert_equal 1, user.reload.failed_attempts
+    user.valid_for_authentication?{ true }
+    assert_equal 0, user.reload.failed_attempts
   end
 
-  test "should respect maximum attempts configuration" do
+  test "should not touch failed_attempts if lock_strategy is none" do
     user = create_user
-    swap Devise, :maximum_attempts => 2 do
-      3.times { authenticated_user = User.authenticate(:email => user.email, :password => "anotherpassword") }
-      assert user.reload.access_locked?
+    user.confirm!
+    swap Devise, :lock_strategy => :none, :maximum_attempts => 2 do
+      3.times { user.valid_for_authentication?{ false } }
+      assert !user.access_locked?
+      assert_equal 0, user.failed_attempts
     end
   end
 
-  test "should clear failed_attempts on successfull sign in" do
+  test 'should be valid for authentication with a unlocked user' do
     user = create_user
-    User.authenticate(:email => user.email, :password => "anotherpassword")
-    assert_equal 1, user.reload.failed_attempts
-    User.authenticate(:email => user.email, :password => "123456")
-    assert_equal 0, user.reload.failed_attempts
+    user.lock_access!
+    user.unlock_access!
+    assert user.valid_for_authentication?{ true }
   end
 
   test "should verify whether a user is locked or not" do
@@ -60,22 +64,13 @@ class LockableTest < ActiveSupport::TestCase
     user.unlock_access!
     assert_nil user.reload.locked_at
     assert_nil user.reload.unlock_token
-    assert 0, user.reload.failed_attempts
-  end
-
-  test "should not lock a locked account" do
-    user = create_user
-    user.lock_access!
-    assert_no_difference "ActionMailer::Base.deliveries.size" do
-      user.lock_access!
-    end
+    assert_equal 0, user.reload.failed_attempts
   end
 
   test 'should not unlock an unlocked user' do
     user = create_user
-
     assert_not user.unlock_access!
-    assert_match /not locked/, user.errors[:email]
+    assert_match "was not locked", user.errors[:email].join
   end
 
   test "new user should not be locked and should have zero failed_attempts" do
@@ -156,22 +151,14 @@ class LockableTest < ActiveSupport::TestCase
 
   test 'should return a new record with errors when a invalid token is given' do
     locked_user = User.unlock_access_by_token('invalid_token')
-    assert locked_user.new_record?
-    assert_match /invalid/, locked_user.errors[:unlock_token]
+    assert_not locked_user.persisted?
+    assert_equal "is invalid", locked_user.errors[:unlock_token].join
   end
 
   test 'should return a new record with errors when a blank token is given' do
     locked_user = User.unlock_access_by_token('')
-    assert locked_user.new_record?
-    assert_match /blank/, locked_user.errors[:unlock_token]
-  end
-
-  test 'should authenticate a unlocked user' do
-    user = create_user
-    user.lock_access!
-    user.unlock_access!
-    authenticated_user = User.authenticate(:email => user.email, :password => user.password)
-    assert_equal authenticated_user, user
+    assert_not locked_user.persisted?
+    assert_equal "can't be blank", locked_user.errors[:unlock_token].join
   end
 
   test 'should find a user to send unlock instructions' do
@@ -183,20 +170,19 @@ class LockableTest < ActiveSupport::TestCase
 
   test 'should return a new user if no email was found' do
     unlock_user = User.send_unlock_instructions(:email => "invalid@email.com")
-    assert unlock_user.new_record?
+    assert_not unlock_user.persisted?
   end
 
   test 'should add error to new user email if no email was found' do
     unlock_user = User.send_unlock_instructions(:email => "invalid@email.com")
-    assert unlock_user.errors[:email]
-    assert_equal 'not found', unlock_user.errors[:email]
+    assert_equal 'not found', unlock_user.errors[:email].join
   end
 
   test 'should not be able to send instructions if the user is not locked' do
     user = create_user
     assert_not user.resend_unlock_token
     assert_not user.access_locked?
-    assert_equal 'not locked', user.errors[:email]
+    assert_equal 'was not locked', user.errors[:email].join
   end
 
 end

data/test/models/recoverable_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class RecoverableTest < ActiveSupport::TestCase
 
@@ -82,8 +82,8 @@ class RecoverableTest < ActiveSupport::TestCase
 
   test 'should return a new record with errors if user was not found by e-mail' do
     reset_password_user = User.send_reset_password_instructions(:email => "invalid@email.com")
-    assert reset_password_user.new_record?
-    assert_match /not found/, reset_password_user.errors[:email]
+    assert_not reset_password_user.persisted?
+    assert_equal "not found", reset_password_user.errors[:email].join
   end
 
   test 'should reset reset_password_token before send the reset instructions email' do
@@ -110,14 +110,14 @@ class RecoverableTest < ActiveSupport::TestCase
 
   test 'should a new record with errors if no reset_password_token is found' do
     reset_password_user = User.reset_password_by_token(:reset_password_token => 'invalid_token')
-    assert reset_password_user.new_record?
-    assert_match /invalid/, reset_password_user.errors[:reset_password_token]
+    assert_not reset_password_user.persisted?
+    assert_equal "is invalid", reset_password_user.errors[:reset_password_token].join
   end
 
   test 'should a new record with errors if reset_password_token is blank' do
     reset_password_user = User.reset_password_by_token(:reset_password_token => '')
-    assert reset_password_user.new_record?
-    assert_match /blank/, reset_password_user.errors[:reset_password_token]
+    assert_not reset_password_user.persisted?
+    assert_match "can't be blank", reset_password_user.errors[:reset_password_token].join
   end
 
   test 'should reset successfully user password given the new password and confirmation' do

data/test/models/rememberable_test.rb

@@ -1,11 +1,6 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class RememberableTest < ActiveSupport::TestCase
-
-  def setup
-    Devise.remember_for = 1
-  end
-
   test 'should respond to remember_me attribute' do
     user = new_user
     assert user.respond_to?(:remember_me)
@@ -23,19 +18,19 @@ class RememberableTest < ActiveSupport::TestCase
   test 'forget_me should clear remember token and save the record without validating' do
     user = create_user
     user.remember_me!
-    assert user.remember_token?
+    assert_not user.remember_token.nil?
     user.expects(:valid?).never
     user.forget_me!
-    assert_not user.remember_token?
+    assert user.remember_token.nil?
     assert_not user.changed?
   end
 
   test 'forget_me should clear remember_created_at' do
     user = create_user
     user.remember_me!
-    assert user.remember_created_at?
+    assert_not user.remember_created_at.nil?
     user.forget_me!
-    assert_not user.remember_created_at?
+    assert user.remember_created_at.nil?
   end
 
   test 'forget should do nothing if no remember token exists' do
@@ -44,45 +39,25 @@ class RememberableTest < ActiveSupport::TestCase
     user.forget_me!
   end
 
-  test 'valid remember token' do
-    user = create_user
-    assert_not user.valid_remember_token?(user.remember_token)
-    user.remember_me!
-    assert user.valid_remember_token?(user.remember_token)
-    user.forget_me!
-    assert_not user.valid_remember_token?(user.remember_token)
-  end
-
-  test 'valid remember token should also verify if remember is not expired' do
-    user = create_user
-    user.remember_me!
-    user.remember_created_at = 3.days.ago
-    user.save
-    assert_not user.valid_remember_token?(user.remember_token)
-  end
-
   test 'serialize into cookie' do
     user = create_user
     user.remember_me!
-    assert_equal "#{user.id}::#{user.remember_token}", User.serialize_into_cookie(user)
+    assert_equal [user.id, user.remember_token], User.serialize_into_cookie(user)
   end
 
   test 'serialize from cookie' do
     user = create_user
     user.remember_me!
-    assert_equal user, User.serialize_from_cookie("#{user.id}::#{user.remember_token}")
+    assert_equal user, User.serialize_from_cookie(user.id, user.remember_token)
   end
 
-  # MongoMapper cries if an invalid ID is given, so this does not need to be tested
-  unless DEVISE_ORM == :mongo_mapper
-    test 'serialize should return nil if no user is found' do
-      assert_nil User.serialize_from_cookie('0::123')
-    end
+  test 'serialize should return nil if no user is found' do
+    assert_nil User.serialize_from_cookie(0, "123")
   end
 
   test 'remember me return nil if is a valid user with invalid token' do
     user = create_user
-    assert_nil User.serialize_from_cookie("#{user.id}::#{user.remember_token}123")
+    assert_nil User.serialize_from_cookie(user.id, "123")
   end
 
   test 'remember for should fallback to devise remember for default configuration' do
@@ -132,4 +107,112 @@ class RememberableTest < ActiveSupport::TestCase
       assert_not user.remember_expired?
     end
   end
+
+  test 'if extend_remember_period is false, remember_me! should generate a new timestamp if expired' do
+    swap Devise, :remember_for => 5.minutes do
+      user = create_user
+      user.remember_me!(false)
+      assert user.remember_created_at
+
+      user.remember_created_at = old = 10.minutes.ago
+      user.save
+
+      user.remember_me!(false)
+      assert_not_equal old.to_i, user.remember_created_at.to_i
+    end
+  end
+
+  test 'if extend_remember_period is false, remember_me! should not generate a new timestamp' do
+    swap Devise, :remember_for => 1.year do
+      user = create_user
+      user.remember_me!(false)
+      assert user.remember_created_at
+
+      user.remember_created_at = old = 10.minutes.ago.utc
+      user.save
+
+      user.remember_me!(false)
+      assert_equal old.to_i, user.remember_created_at.to_i
+    end
+  end
+
+  test 'if extend_remember_period is true, remember_me! should always generate a new timestamp' do
+    swap Devise, :remember_for => 1.year do
+      user = create_user
+      user.remember_me!(true)
+      assert user.remember_created_at
+
+      user.remember_created_at = old = 10.minutes.ago
+      user.save
+
+      user.remember_me!(true)
+      assert_not_equal old, user.remember_created_at
+    end
+  end
+
+  test 'if remember_across_browsers is true, remember_me! should create a new token if no token exists' do
+    swap Devise, :remember_across_browsers => true, :remember_for => 1.year do
+      user = create_user
+      assert_equal nil, user.remember_token
+      user.remember_me!
+      assert_not_equal nil, user.remember_token
+    end
+  end
+
+  test 'if remember_across_browsers is true, remember_me! should create a new token if a token exists but has expired' do
+    swap Devise, :remember_across_browsers => true, :remember_for => 1.day do
+      user = create_user
+      user.remember_me!
+      user.remember_created_at = 2.days.ago
+      user.save
+      token = user.remember_token
+      user.remember_me!
+      assert_not_equal token, user.remember_token
+    end
+  end
+
+  test 'if remember_across_browsers is true, remember_me! should not create a new token if a token exists and has not expired' do
+    swap Devise, :remember_across_browsers => true, :remember_for => 2.days do
+      user = create_user
+      user.remember_me!
+      user.remember_created_at = 1.day.ago
+      user.save
+      token = user.remember_token
+      user.remember_me!
+      assert_equal token, user.remember_token
+    end
+  end
+
+  test 'if remember_across_browsers is false, remember_me! should create a new token if no token exists' do
+    swap Devise, :remember_across_browsers => false do
+      user = create_user
+      assert_equal nil, user.remember_token
+      user.remember_me!
+      assert_not_equal nil, user.remember_token
+    end
+  end
+
+  test 'if remember_across_browsers is false, remember_me! should create a new token if a token exists but has expired' do
+    swap Devise, :remember_across_browsers => false, :remember_for => 1.day do
+      user = create_user
+      user.remember_me!
+      user.remember_created_at = 2.days.ago
+      user.save
+      token = user.remember_token
+      user.remember_me!
+      assert_not_equal token, user.remember_token
+    end
+  end
+
+  test 'if remember_across_browsers is false, remember_me! should create a new token if a token exists and has not expired' do
+    swap Devise, :remember_across_browsers => false, :remember_for => 2.days do
+      user = create_user
+      user.remember_me!
+      user.remember_created_at = 1.day.ago
+      user.save
+      token = user.remember_token
+      user.remember_me!
+      assert_not_equal token, user.remember_token
+    end
+  end
 end

data/test/models/timeoutable_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class TimeoutableTest < ActiveSupport::TestCase
 

data/test/models/token_authenticatable_test.rb

@@ -1,14 +1,7 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class TokenAuthenticatableTest < ActiveSupport::TestCase
 
-  test 'should generate friendly authentication token on create' do
-    User.expects(:authentication_token).returns(VALID_AUTHENTICATION_TOKEN)
-    user = create_user
-    assert_present user.authentication_token
-    assert_equal VALID_AUTHENTICATION_TOKEN, user.authentication_token
-  end
-
   test 'should reset authentication token' do
     user = new_user
     user.reset_authentication_token
@@ -25,26 +18,19 @@ class TokenAuthenticatableTest < ActiveSupport::TestCase
     assert_equal previous_token, user.authentication_token
   end
 
-  test 'should test for a valid authentication token' do
-    User.expects(:authentication_token).returns(VALID_AUTHENTICATION_TOKEN)
-    user = create_user
-    assert user.valid_authentication_token?(VALID_AUTHENTICATION_TOKEN)
-    assert_not user.valid_authentication_token?(VALID_AUTHENTICATION_TOKEN.reverse)
-  end
-
   test 'should authenticate a valid user with authentication token and return it' do
-    User.expects(:authentication_token).returns(VALID_AUTHENTICATION_TOKEN)
     user = create_user
+    user.ensure_authentication_token!
     user.confirm!
-    authenticated_user = User.authenticate_with_token(:auth_token => user.authentication_token)
+    authenticated_user = User.find_for_token_authentication(:auth_token => user.authentication_token)
     assert_equal authenticated_user, user
   end
 
   test 'should return nil when authenticating an invalid user by authentication token' do
-    User.expects(:authentication_token).returns(VALID_AUTHENTICATION_TOKEN)
     user = create_user
+    user.ensure_authentication_token!
     user.confirm!
-    authenticated_user = User.authenticate_with_token(:auth_token => user.authentication_token.reverse)
+    authenticated_user = User.find_for_token_authentication(:auth_token => user.authentication_token.reverse)
     assert_nil authenticated_user
   end
 

data/test/models/trackable_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class TrackableTest < ActiveSupport::TestCase
 

data/test/models/validatable_test.rb

@@ -1,37 +1,34 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class ValidatableTest < ActiveSupport::TestCase
-  extend Devise::TestSilencer if [:mongo_mapper, :data_mapper].include?(DEVISE_ORM)
-
   test 'should require email to be set' do
     user = new_user(:email => nil)
     assert user.invalid?
     assert user.errors[:email]
-    assert_equal 'can\'t be blank', user.errors[:email]
+    assert_equal 'can\'t be blank', user.errors[:email].join
   end
 
   test 'should require uniqueness of email, allowing blank' do
     existing_user = create_user
+
     user = new_user(:email => '')
     assert user.invalid?
-    assert_not_equal 'has already been taken', user.errors[:email]
+    assert_no_match(/taken/, user.errors[:email].join)
+
     user.email = existing_user.email
     assert user.invalid?
-    assert user.errors[:email]
-    assert_equal 1, [*user.errors[:email]].size
-    assert_equal 'has already been taken', user.errors[:email]
+    assert_match(/taken/, user.errors[:email].join)
   end
 
   test 'should require correct email format, allowing blank' do
     user = new_user(:email => '')
     assert user.invalid?
-    assert_not_equal 'is invalid', user.errors[:email]
+    assert_not_equal 'is invalid', user.errors[:email].join
+
     %w(invalid_email_format email@invalid invalid$character@mail.com other@not 123).each do |email|
       user.email = email
       assert user.invalid?, 'should be invalid with email ' << email
-      assert user.errors[:email]
-      assert_equal 1, [*user.errors[:email]].size
-      assert_equal 'is invalid', user.errors[:email]
+      assert_equal 'is invalid', user.errors[:email].join
     end
   end
 
@@ -39,63 +36,59 @@ class ValidatableTest < ActiveSupport::TestCase
     %w(a.b.c@example.com test_mail@gmail.com any@any.net email@test.br 123@mail.test).each do |email|
       user = new_user(:email => email)
       assert user.valid?, 'should be valid with email ' << email
-      assert_nil user.errors[:email]
+      assert_blank user.errors[:email]
     end
   end
 
   test 'should require password to be set when creating a new record' do
     user = new_user(:password => '', :password_confirmation => '')
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'can\'t be blank', user.errors[:password]
+    assert_equal 'can\'t be blank', user.errors[:password].join
   end
 
   test 'should require confirmation to be set when creating a new record' do
     user = new_user(:password => 'new_password', :password_confirmation => 'blabla')
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'doesn\'t match confirmation', user.errors[:password]
+    assert_equal 'doesn\'t match confirmation', user.errors[:password].join
   end
 
   test 'should require password when updating/reseting password' do
     user = create_user
+
     user.password = ''
     user.password_confirmation = ''
+
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'can\'t be blank', user.errors[:password]
+    assert_equal 'can\'t be blank', user.errors[:password].join
   end
 
   test 'should require confirmation when updating/reseting password' do
     user = create_user
     user.password_confirmation = 'another_password'
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'doesn\'t match confirmation', user.errors[:password]
+    assert_equal 'doesn\'t match confirmation', user.errors[:password].join
   end
 
   test 'should require a password with minimum of 6 characters' do
     user = new_user(:password => '12345', :password_confirmation => '12345')
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'is too short (minimum is 6 characters)', user.errors[:password]
+    assert_equal 'is too short (minimum is 6 characters)', user.errors[:password].join
   end
 
   test 'should require a password with maximum of 20 characters long' do
     user = new_user(:password => 'x'*21, :password_confirmation => 'x'*21)
     assert user.invalid?
-    assert user.errors[:password]
-    assert_equal 'is too long (maximum is 20 characters)', user.errors[:password]
+    assert_equal 'is too long (maximum is 20 characters)', user.errors[:password].join
   end
 
   test 'should not require password length when it\'s not changed' do
     user = create_user.reload
     user.password = user.password_confirmation = nil
     assert user.valid?
+  
     user.password_confirmation = 'confirmation'
     assert user.invalid?
-    assert user.errors[:password]
-    assert_not user.errors[:password].to_a.include?('is too short (minimum is 6 characters)')
+    assert_not (user.errors[:password].join =~ /is too long/)
   end
 
   test 'shuold not be included in objects with invalid API' do

data/test/models_test.rb

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require 'test_helper'
 
 class Configurable < User
   devise :database_authenticatable, :confirmable, :rememberable, :timeoutable, :lockable,
@@ -6,6 +6,9 @@ class Configurable < User
          :remember_for => 7.days, :timeout_in => 15.minutes, :unlock_in => 10.days
 end
 
+class Inheritable < Admin
+end
+
 class ActiveRecordTest < ActiveSupport::TestCase
   def include_module?(klass, mod)
     klass.devise_modules.include?(mod) &&
@@ -22,13 +25,17 @@ class ActiveRecordTest < ActiveSupport::TestCase
     end
   end
 
-  test 'add modules cherry pick' do
-    assert_include_modules Admin, :database_authenticatable, :registerable, :timeoutable
+  test 'can cherry pick modules' do
+    assert_include_modules Admin, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable
+  end
+
+  test 'chosen modules are inheritable' do
+    assert_include_modules Inheritable, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable
   end
 
   test 'order of module inclusion' do
-    correct_module_order   = [:database_authenticatable, :registerable, :timeoutable]
-    incorrect_module_order = [:database_authenticatable, :timeoutable, :registerable]
+    correct_module_order   = [:database_authenticatable, :recoverable, :registerable, :lockable, :timeoutable]
+    incorrect_module_order = [:database_authenticatable, :timeoutable, :registerable, :recoverable, :lockable]
 
     assert_include_modules Admin, *incorrect_module_order
 

data/test/orm/active_record.rb

@@ -1,29 +1,7 @@
-require File.join(File.dirname(__FILE__), '..', 'rails_app', 'config', 'environment')
-require 'test_help'
-
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Base.logger = Logger.new(nil)
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
-ActiveRecord::Schema.define(:version => 1) do
-  [:users, :admins, :accounts].each do |table|
-    create_table table do |t|
-      t.database_authenticatable :null => table == :admins
 
-      if table != :admin
-        t.string :username
-        t.confirmable
-        t.recoverable
-        t.rememberable
-        t.trackable
-        t.lockable
-        t.token_authenticatable
-      end
-
-      t.timestamps
-    end
-  end
-end
+ActiveRecord::Migrator.migrate(File.expand_path("../../rails_app/db/migrate/", __FILE__))
 
 class ActiveSupport::TestCase
   self.use_transactional_fixtures = true

data/test/orm/mongoid.rb

@@ -0,0 +1,10 @@
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new('127.0.0.1', 27017).db("devise-test-suite")
+end
+
+class ActiveSupport::TestCase
+  setup do
+    User.delete_all
+    Admin.delete_all
+  end
+end

data/test/rails_app/app/active_record/admin.rb

@@ -1,7 +1,3 @@
 class Admin < ActiveRecord::Base
-  devise :database_authenticatable, :registerable, :timeoutable
-
-  def self.find_for_authentication(conditions)
-    last(:conditions => conditions)
-  end
+  devise :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable, :unlock_strategy => :time
 end

data/test/rails_app/app/active_record/shim.rb

@@ -0,0 +1,2 @@
+module Shim
+end

data/test/rails_app/app/active_record/user.rb

@@ -1,7 +1,7 @@
 class User < ActiveRecord::Base
-  devise :database_authenticatable, :http_authenticatable, :confirmable,
-         :lockable, :recoverable, :registerable, :rememberable, :timeoutable,
-         :token_authenticatable, :trackable, :validatable
+  devise :database_authenticatable, :confirmable, :lockable, :recoverable,
+         :registerable, :rememberable, :timeoutable, :token_authenticatable,
+         :trackable, :validatable
 
   attr_accessible :username, :email, :password, :password_confirmation
 end