devise 0.6.1 → 0.6.2

data/test/integration/trackable_test.rb

@@ -0,0 +1,64 @@
+require 'test/test_helper'
+
+class TrackableHooksTest < ActionController::IntegrationTest
+
+  test "current and last sign in timestamps are updated on each sign in" do
+    user = create_user
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+
+    sign_in_as_user
+    user.reload
+
+    assert_kind_of Time, user.current_sign_in_at
+    assert_kind_of Time, user.last_sign_in_at
+
+    assert_equal user.current_sign_in_at, user.last_sign_in_at
+    assert user.current_sign_in_at >= user.created_at
+
+    visit destroy_user_session_path
+    new_time = 2.seconds.from_now
+    Time.stubs(:now).returns(new_time)
+
+    sign_in_as_user
+    user.reload
+    assert user.current_sign_in_at > user.last_sign_in_at
+  end
+
+  test "current and last sign in remote ip are updated on each sign in" do
+    user = create_user
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+
+    sign_in_as_user
+    user.reload
+
+    assert_equal "127.0.0.1", user.current_sign_in_ip
+    assert_equal "127.0.0.1", user.last_sign_in_ip
+  end
+
+  test "increase sign in count" do
+    user = create_user
+    assert_nil user.sign_in_count
+
+    sign_in_as_user
+    user.reload
+    assert_equal 1, user.sign_in_count
+
+    visit destroy_user_session_path
+    sign_in_as_user
+    user.reload
+    assert_equal 2, user.sign_in_count
+  end
+
+  test "does not update anything if user is signed out along the way" do
+    swap Devise, :confirm_within => 0 do
+      user = create_user(:confirm => false)
+      sign_in_as_user
+
+      user.reload
+      assert_nil user.current_sign_in_at
+      assert_nil user.last_sign_in_at
+    end
+  end
+end

data/test/models/authenticatable_test.rb

@@ -13,11 +13,10 @@ class AuthenticatableTest < ActiveSupport::TestCase
     assert user.respond_to?(:password_confirmation)
   end
 
-  test 'should generate salt while setting password' do
-    assert_present new_user.password_salt
-    assert_present new_user(:password => nil).password_salt
-    assert_present new_user(:password => '').password_salt
-    assert_present create_user.password_salt
+  test 'should generate encrypted password and salt while setting password' do
+    user = new_user
+    assert_present user.password_salt
+    assert_present user.encrypted_password
   end
 
   test 'should not change password salt when updating' do
@@ -33,20 +32,14 @@ class AuthenticatableTest < ActiveSupport::TestCase
     assert_equal 'friendly_token', new_user.password_salt
   end
 
-  test 'should never generate the same salt for different users' do
-    password_salts = []
-    10.times do
-      salt = create_user.password_salt
-      assert_not password_salts.include?(salt)
-      password_salts << salt
-    end
+  test 'should not generate salt if password is blank' do
+    assert_blank new_user(:password => nil).password_salt
+    assert_blank new_user(:password => '').password_salt
   end
 
-  test 'should generate encrypted password while setting password' do
-    assert_present new_user.encrypted_password
-    assert_present new_user(:password => nil).encrypted_password
-    assert_present new_user(:password => '').encrypted_password
-    assert_present create_user.encrypted_password
+  test 'should not generate encrypted password if password is blank' do
+    assert_blank new_user(:password => nil).encrypted_password
+    assert_blank new_user(:password => '').encrypted_password
   end
 
   test 'should encrypt password again if password has changed' do
@@ -57,31 +50,28 @@ class AuthenticatableTest < ActiveSupport::TestCase
     assert_not_equal encrypted_password, user.encrypted_password
   end
 
-  test 'should fallback to Sha1 as default encryption' do
+  test 'should fallback to sha1 as default encryption' do
     user = new_user
     assert_equal encrypt_password(user), user.encrypted_password
   end
 
-  test 'should fallback to devise pepper default configuring' do
+  test 'should fallback to devise pepper default configuration' do
     begin
       Devise.pepper = ''
       user = new_user
       assert_equal encrypt_password(user), user.encrypted_password
       assert_not_equal encrypt_password(user, 'another_pepper'), user.encrypted_password
+
       Devise.pepper = 'new_pepper'
       user = new_user
       assert_equal encrypt_password(user, 'new_pepper'), user.encrypted_password
       assert_not_equal encrypt_password(user, 'another_pepper'), user.encrypted_password
-      Devise.pepper = '123456'
-      user = new_user
-      assert_equal encrypt_password(user, '123456'), user.encrypted_password
-      assert_not_equal encrypt_password(user, 'another_pepper'), user.encrypted_password
     ensure
       Devise.pepper = nil
     end
   end
 
-  test 'should fallback to devise stretches default configuring' do
+  test 'should fallback to devise stretches default configuration' do
     swap Devise, :stretches => 1 do
       user = new_user
       assert_equal encrypt_password(user, nil, 1), user.encrypted_password
@@ -140,11 +130,6 @@ class AuthenticatableTest < ActiveSupport::TestCase
     assert_not_nil Admin.authenticate(:email => admin.email, :password => admin.password)
   end
 
-  test 'should never authenticate an account' do
-    account = Account.create!(valid_attributes)
-    assert_nil Account.authenticate(:email => account.email, :password => account.password)
-  end
-
   test 'should serialize user into session' do
     user = create_user
     assert_equal [User, user.id], User.serialize_into_session(user)
@@ -155,16 +140,16 @@ class AuthenticatableTest < ActiveSupport::TestCase
     assert_equal user.id, User.serialize_from_session([User, user.id]).id
   end
 
-  test 'should not serialize another klass from session' do
+  test 'should serialize another klass from session if it is an ancestors' do
     user = create_user
-    assert_raise RuntimeError, /ancestors/ do
-      User.serialize_from_session([Admin, user.id])
-    end
+    klass = Class.new(User)
+    assert_equal user.id, User.serialize_from_session([klass, user.id]).id
   end
 
-  test 'should serialize another klass from session' do
+  test 'should not serialize another klass from session if not an ancestors' do
     user = create_user
-    klass = Class.new(User)
-    assert_equal user.id, User.serialize_from_session([klass, user.id]).id
+    assert_raise RuntimeError, /ancestors/ do
+      User.serialize_from_session([Admin, user.id])
+    end
   end
 end

data/test/models/confirmable_test.rb

@@ -22,14 +22,14 @@ class ConfirmableTest < ActiveSupport::TestCase
 
   test 'should never generate the same confirmation token for different users' do
     confirmation_tokens = []
-    10.times do
+    3.times do
       token = create_user.confirmation_token
       assert !confirmation_tokens.include?(token)
       confirmation_tokens << token
     end
   end
 
-  test 'should confirm a user updating confirmed at' do
+  test 'should confirm a user by updating confirmed at' do
     user = create_user
     assert_nil user.confirmed_at
     assert user.confirm!
@@ -51,37 +51,37 @@ class ConfirmableTest < ActiveSupport::TestCase
     assert user.confirmed?
   end
 
-  test 'should not confirm a user already confirmed and add an error to email' do
+  test 'should not confirm a user already confirmed' do
     user = create_user
     assert user.confirm!
     assert_nil user.errors[:email]
+
     assert_not user.confirm!
-    assert_not_nil user.errors[:email]
     assert_equal 'already confirmed', user.errors[:email]
   end
 
   test 'should find and confirm an user automatically' do
     user = create_user
     confirmed_user = User.confirm!(:confirmation_token => user.confirmation_token)
-    assert_not_nil confirmed_user
     assert_equal confirmed_user, user
     assert user.reload.confirmed?
   end
 
-  test 'should return a new user with errors if no user exists while trying to confirm' do
+  test 'should return a new record with errors when a invalid token is given' do
     confirmed_user = User.confirm!(:confirmation_token => 'invalid_confirmation_token')
     assert confirmed_user.new_record?
+    assert_equal "is invalid", confirmed_user.errors[:confirmation_token]
   end
 
-  test 'should return errors for a new user when trying to confirm' do
-    confirmed_user = User.confirm!(:confirmation_token => 'invalid_confirmation_token')
-    assert_not_nil confirmed_user.errors[:confirmation_token]
-    assert_equal 'is invalid', confirmed_user.errors[:confirmation_token]
+  test 'should return a new record with errors when a blank token is given' do
+    confirmed_user = User.confirm!(:confirmation_token => '')
+    assert confirmed_user.new_record?
+    assert_equal "can't be blank", confirmed_user.errors[:confirmation_token]
   end
 
   test 'should generate errors for a user email if user is already confirmed' do
     user = create_user
-    user.confirm!
+    user.update_attribute(:confirmed_at, Time.now)
     confirmed_user = User.confirm!(:confirmation_token => user.confirmation_token)
     assert confirmed_user.confirmed?
     assert confirmed_user.errors[:email]
@@ -91,7 +91,6 @@ class ConfirmableTest < ActiveSupport::TestCase
     user = create_user
     user.confirm!
     authenticated_user = User.authenticate(:email => user.email, :password => user.password)
-    assert_not_nil authenticated_user
     assert_equal authenticated_user, user
   end
 
@@ -112,13 +111,11 @@ class ConfirmableTest < ActiveSupport::TestCase
   test 'should find a user to send confirmation instructions' do
     user = create_user
     confirmation_user = User.send_confirmation_instructions(:email => user.email)
-    assert_not_nil confirmation_user
     assert_equal confirmation_user, user
   end
 
   test 'should return a new user if no email was found' do
     confirmation_user = User.send_confirmation_instructions(:email => "invalid@email.com")
-    assert_not_nil confirmation_user
     assert confirmation_user.new_record?
   end
 
@@ -173,65 +170,53 @@ class ConfirmableTest < ActiveSupport::TestCase
     user.confirm!
     assert_not user.reset_confirmation!
     assert user.confirmed?
-    assert user.errors[:email].present?
     assert_equal 'already confirmed', user.errors[:email]
   end
 
   test 'confirm time should fallback to devise confirm in default configuration' do
-    begin
-      confirm_within = Devise.confirm_within
-      Devise.confirm_within = 1.day
+    swap Devise, :confirm_within => 1.day do
       user = new_user
       user.confirmation_sent_at = 2.days.ago
       assert_not user.active?
+
       Devise.confirm_within = 3.days
       assert user.active?
-    ensure
-      Devise.confirm_within = confirm_within
     end
   end
 
   test 'should be active when confirmation sent at is not overpast' do
-    Devise.confirm_within = 5.days
-    user = create_user
-    user.confirmation_sent_at = 4.days.ago
-    assert user.active?
+    swap Devise, :confirm_within => 5.days do
+      Devise.confirm_within = 5.days
+      user = create_user
+
+      user.confirmation_sent_at = 4.days.ago
+      assert user.active?
+
+      user.confirmation_sent_at = 5.days.ago
+      assert_not user.active?
+    end
   end
 
   test 'should be active when already confirmed' do
     user = create_user
     assert_not user.confirmed?
     assert_not user.active?
+
     user.confirm!
     assert user.confirmed?
     assert user.active?
   end
 
-  test 'should not be active when confirmation was sent within the limit' do
-    Devise.confirm_within = 5.days
-    user = create_user
-    user.confirmation_sent_at = 5.days.ago
-    assert_not user.active?
-  end
-
-  test 'should be active when confirm in is zero' do
+  test 'should not be active when confirm in is zero' do
     Devise.confirm_within = 0.days
     user = create_user
     user.confirmation_sent_at = Date.today
     assert_not user.active?
   end
 
-  test 'should not be active when confirmation was sent before confirm in time' do
-    Devise.confirm_within = 4.days
-    user = create_user
-    user.confirmation_sent_at = 5.days.ago
-    assert_not user.active?
-  end
-
   test 'should not be active without confirmation' do
     user = create_user
     user.update_attribute(:confirmation_sent_at, nil)
     assert_not user.reload.active?
   end
-
 end

data/test/models/recoverable_test.rb

@@ -8,7 +8,6 @@ class RecoverableTest < ActiveSupport::TestCase
 
   test 'should not generate reset password token after creating a record' do
     assert_nil new_user.reset_password_token
-    assert_nil create_user.reset_password_token
   end
 
   test 'should regenerate reset password token each time' do
@@ -22,7 +21,7 @@ class RecoverableTest < ActiveSupport::TestCase
 
   test 'should never generate the same reset password token for different users' do
     reset_password_tokens = []
-    10.times do
+    3.times do
       user = create_user
       user.send_reset_password_instructions
       token = user.reset_password_token
@@ -45,6 +44,7 @@ class RecoverableTest < ActiveSupport::TestCase
   test 'should clear reset password token while reseting the password' do
     user = create_user
     assert_nil user.reset_password_token
+
     user.send_reset_password_instructions
     assert_present user.reset_password_token
     assert user.reset_password!('123456789', '123456789')
@@ -77,64 +77,61 @@ class RecoverableTest < ActiveSupport::TestCase
   test 'should find a user to send instructions by email' do
     user = create_user
     reset_password_user = User.send_reset_password_instructions(:email => user.email)
-    assert_not_nil reset_password_user
     assert_equal reset_password_user, user
   end
 
-  test 'should return a new user if no email was found' do
+  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_not_nil reset_password_user
     assert reset_password_user.new_record?
-  end
-
-  test 'should add error to new user email if no email was found' do
-    reset_password_user = User.send_reset_password_instructions(:email => "invalid@email.com")
-    assert reset_password_user.errors[:email]
     assert_equal 'not found', reset_password_user.errors[:email]
   end
 
-  test 'should reset reset password token before send the reset instructions email' do
+  test 'should reset reset_password_token before send the reset instructions email' do
     user = create_user
     token = user.reset_password_token
     reset_password_user = User.send_reset_password_instructions(:email => user.email)
     assert_not_equal token, user.reload.reset_password_token
   end
 
-  test 'should send email instructions to the user reset it\'s password' do
+  test 'should send email instructions to the user reset his password' do
     user = create_user
     assert_email_sent do
       User.send_reset_password_instructions(:email => user.email)
     end
   end
 
-  test 'should find a user to reset it\'s password based on reset_password_token' do
+  test 'should find a user to reset his password based on reset_password_token' do
     user = create_user
+    user.send :generate_reset_password_token!
+
     reset_password_user = User.reset_password!(:reset_password_token => user.reset_password_token)
-    assert_not_nil reset_password_user
     assert_equal reset_password_user, user
   end
 
-  test 'should return a new user when trying to reset it\'s password if no reset_password_token is found' do
+  test 'should a new record with errors if no reset_password_token is found' do
     reset_password_user = User.reset_password!(:reset_password_token => 'invalid_token')
-    assert_not_nil reset_password_user
     assert reset_password_user.new_record?
+    assert_equal 'is invalid', reset_password_user.errors[:reset_password_token]
   end
 
-  test 'should add error to new user email if no reset password token was found' do
-    reset_password_user = User.reset_password!(:reset_password_token => "invalid_token")
-    assert reset_password_user.errors[:reset_password_token]
-    assert_equal 'is invalid', reset_password_user.errors[:reset_password_token]
+  test 'should a new record with errors if reset_password_token is blank' do
+    reset_password_user = User.reset_password!(:reset_password_token => '')
+    assert reset_password_user.new_record?
+    assert_equal "can't be blank", reset_password_user.errors[:reset_password_token]
   end
 
   test 'should reset successfully user password given the new password and confirmation' do
     user = create_user
     old_password = user.password
+    user.send :generate_reset_password_token!
+
     reset_password_user = User.reset_password!(
       :reset_password_token => user.reset_password_token,
       :password => 'new_password',
       :password_confirmation => 'new_password'
     )
     user.reload
+
     assert_not user.valid_password?(old_password)
     assert user.valid_password?('new_password')
   end

data/test/models/rememberable_test.rb

@@ -82,49 +82,48 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember for should fallback to devise remember for default configuration' do
-    begin
-      remember_for = Devise.remember_for
+    swap Devise, :remember_for => 1.day do
       user = create_user
-      Devise.remember_for = 1.day
       user.remember_me!
       assert_not user.remember_expired?
-      Devise.remember_for = 0.days
-      user.remember_me!
-      assert user.remember_expired?
-    ensure
-      Devise.remember_for = remember_for
     end
   end
 
   test 'remember expires at should sum date of creation with remember for configuration' do
-    Devise.remember_for = 3.days
-    user = create_user
-    user.remember_me!
-    assert_equal 3.days.from_now.to_date, user.remember_expires_at.to_date
-    Devise.remember_for = 5.days
-    assert_equal 5.days.from_now.to_date, user.remember_expires_at.to_date
+    swap Devise, :remember_for => 3.days do
+      user = create_user
+      user.remember_me!
+      assert_equal 3.days.from_now.to_date, user.remember_expires_at.to_date
+
+      Devise.remember_for = 5.days
+      assert_equal 5.days.from_now.to_date, user.remember_expires_at.to_date
+    end
   end
 
   test 'remember should be expired if remember_for is zero' do
-    Devise.remember_for = 0.days
-    user = create_user
-    user.remember_me!
-    assert user.remember_expired?
+    swap Devise, :remember_for => 0.days do
+      Devise.remember_for = 0.days
+      user = create_user
+      user.remember_me!
+      assert user.remember_expired?
+    end
   end
 
   test 'remember should be expired if it was created before limit time' do
-    Devise.remember_for = 1.day
-    user = create_user
-    user.remember_me!
-    user.update_attribute(:remember_created_at, 2.days.ago)
-    assert user.remember_expired?
+    swap Devise, :remember_for => 1.day do
+      user = create_user
+      user.remember_me!
+      user.update_attribute(:remember_created_at, 2.days.ago)
+      assert user.remember_expired?
+    end
   end
 
   test 'remember should not be expired if it was created whitin the limit time' do
-    Devise.remember_for = 30.days
-    user = create_user
-    user.remember_me!
-    user.update_attribute(:remember_created_at, 30.days.ago + 2.minutes)
-    assert_not user.remember_expired?
+    swap Devise, :remember_for => 30.days do
+      user = create_user
+      user.remember_me!
+      user.update_attribute(:remember_created_at, 30.days.ago + 2.minutes)
+      assert_not user.remember_expired?
+    end
   end
 end