devise 4.1.1 → 4.2.0

data/test/models/database_authenticatable_test.rb

@@ -124,7 +124,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should test for a valid password' do
     user = create_user
     assert user.valid_password?('12345678')
-    assert_not user.valid_password?('654321')
+    refute user.valid_password?('654321')
   end
 
   test 'should not raise error with an empty password' do
@@ -136,7 +136,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should be an invalid password if the user has an empty password' do
     user = create_user
     user.encrypted_password = ''
-    assert_not user.valid_password?('654321')
+    refute user.valid_password?('654321')
   end
 
   test 'should respond to current password' do
@@ -152,7 +152,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
 
   test 'should add an error to current password when it is invalid' do
     user = create_user
-    assert_not user.update_with_password(current_password: 'other',
+    refute user.update_with_password(current_password: 'other',
       password: 'pass4321', password_confirmation: 'pass4321')
     assert user.reload.valid_password?('12345678')
     assert_match "is invalid", user.errors[:current_password].join
@@ -160,7 +160,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
 
   test 'should add an error to current password when it is blank' do
     user = create_user
-    assert_not user.update_with_password(password: 'pass4321',
+    refute user.update_with_password(password: 'pass4321',
       password_confirmation: 'pass4321')
     assert user.reload.valid_password?('12345678')
     assert_match "can't be blank", user.errors[:current_password].join
@@ -170,7 +170,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
     user = UserWithValidation.create!(valid_attributes)
     user.save
     assert user.persisted?
-    assert_not user.update_with_password(username: "")
+    refute user.update_with_password(username: "")
     assert_match "usertest", user.reload.username
     assert_match "can't be blank", user.errors[:username].join
   end
@@ -183,14 +183,14 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
 
   test 'should not update password with invalid confirmation' do
     user = create_user
-    assert_not user.update_with_password(current_password: '12345678',
+    refute user.update_with_password(current_password: '12345678',
       password: 'pass4321', password_confirmation: 'other')
     assert user.reload.valid_password?('12345678')
   end
 
   test 'should clean up password fields on failure' do
     user = create_user
-    assert_not user.update_with_password(current_password: '12345678',
+    refute user.update_with_password(current_password: '12345678',
       password: 'pass4321', password_confirmation: 'other')
     assert user.password.blank?
     assert user.password_confirmation.blank?
@@ -217,14 +217,14 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
 
   test 'should not destroy user with invalid password' do
     user = create_user
-    assert_not user.destroy_with_password('other')
+    refute user.destroy_with_password('other')
     assert user.persisted?
     assert_match "is invalid", user.errors[:current_password].join
   end
 
   test 'should not destroy user with blank password' do
     user = create_user
-    assert_not user.destroy_with_password(nil)
+    refute user.destroy_with_password(nil)
     assert user.persisted?
     assert_match "can't be blank", user.errors[:current_password].join
   end
@@ -252,15 +252,15 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   end
 
   test 'required_fields should be encryptable_password and the email field by default' do
-    assert_same_content Devise::Models::DatabaseAuthenticatable.required_fields(User), [
-      :email,
-      :encrypted_password
+    assert_equal Devise::Models::DatabaseAuthenticatable.required_fields(User), [
+      :encrypted_password,
+      :email
     ]
   end
 
   test 'required_fields should be encryptable_password and the login when the login is on authentication_keys' do
     swap Devise, authentication_keys: [:login] do
-      assert_same_content Devise::Models::DatabaseAuthenticatable.required_fields(User), [
+      assert_equal Devise::Models::DatabaseAuthenticatable.required_fields(User), [
         :encrypted_password,
         :login
       ]

data/test/models/lockable_test.rb

@@ -46,7 +46,7 @@ class LockableTest < ActiveSupport::TestCase
 
   test "should verify whether a user is locked or not" do
     user = create_user
-    assert_not user.access_locked?
+    refute user.access_locked?
     user.lock_access!
     assert user.access_locked?
   end
@@ -56,7 +56,7 @@ class LockableTest < ActiveSupport::TestCase
     user.confirm
     assert user.active_for_authentication?
     user.lock_access!
-    assert_not user.active_for_authentication?
+    refute user.active_for_authentication?
   end
 
   test "should unlock a user by cleaning locked_at, failed_attempts and unlock_token" do
@@ -72,7 +72,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "new user should not be locked and should have zero failed_attempts" do
-    assert_not new_user.access_locked?
+    refute new_user.access_locked?
     assert_equal 0, create_user.failed_attempts
   end
 
@@ -83,7 +83,7 @@ class LockableTest < ActiveSupport::TestCase
       assert user.access_locked?
 
       Devise.unlock_in = 1.hour
-      assert_not user.access_locked?
+      refute user.access_locked?
     end
   end
 
@@ -162,18 +162,18 @@ class LockableTest < ActiveSupport::TestCase
     raw  = user.send_unlock_instructions
     locked_user = User.unlock_access_by_token(raw)
     assert_equal locked_user, user
-    assert_not user.reload.access_locked?
+    refute user.reload.access_locked?
   end
 
   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_not locked_user.persisted?
+    refute 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_not locked_user.persisted?
+    refute locked_user.persisted?
     assert_equal "can't be blank", locked_user.errors[:unlock_token].join
   end
 
@@ -186,7 +186,7 @@ class LockableTest < ActiveSupport::TestCase
 
   test 'should return a new user if no email was found' do
     unlock_user = User.send_unlock_instructions(email: "invalid@example.com")
-    assert_not unlock_user.persisted?
+    refute unlock_user.persisted?
   end
 
   test 'should add error to new user email if no email was found' do
@@ -206,23 +206,23 @@ class LockableTest < ActiveSupport::TestCase
     swap Devise, unlock_keys: [:username, :email] do
       user = create_user
       unlock_user = User.send_unlock_instructions(email: user.email)
-      assert_not unlock_user.persisted?
+      refute unlock_user.persisted?
       assert_equal "can't be blank", unlock_user.errors[:username].join
     end
   end
 
   test 'should not be able to send instructions if the user is not locked' do
     user = create_user
-    assert_not user.resend_unlock_instructions
-    assert_not user.access_locked?
+    refute user.resend_unlock_instructions
+    refute user.access_locked?
     assert_equal 'was not locked', user.errors[:email].join
   end
 
   test 'should not be able to send instructions if the user if not locked and have username as unlock key' do
     swap Devise, unlock_keys: [:username] do
       user = create_user
-      assert_not user.resend_unlock_instructions
-      assert_not user.access_locked?
+      refute user.resend_unlock_instructions
+      refute user.access_locked?
       assert_equal 'was not locked', user.errors[:username].join
     end
   end
@@ -257,7 +257,7 @@ class LockableTest < ActiveSupport::TestCase
   test 'required_fields should contain the all the fields when all the strategies are enabled' do
     swap Devise, unlock_strategy: :both do
       swap Devise, lock_strategy: :failed_attempts do
-        assert_same_content Devise::Models::Lockable.required_fields(User), [
+        assert_equal Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :locked_at,
          :unlock_token
@@ -269,7 +269,7 @@ class LockableTest < ActiveSupport::TestCase
   test 'required_fields should contain only failed_attempts and locked_at when the strategies are time and failed_attempts are enabled' do
     swap Devise, unlock_strategy: :time do
       swap Devise, lock_strategy: :failed_attempts do
-        assert_same_content Devise::Models::Lockable.required_fields(User), [
+        assert_equal Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :locked_at
         ]
@@ -280,7 +280,7 @@ class LockableTest < ActiveSupport::TestCase
   test 'required_fields should contain only failed_attempts and unlock_token when the strategies are token and failed_attempts are enabled' do
     swap Devise, unlock_strategy: :email do
       swap Devise, lock_strategy: :failed_attempts do
-        assert_same_content Devise::Models::Lockable.required_fields(User), [
+        assert_equal Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :unlock_token
         ]

data/test/models/omniauthable_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 class OmniauthableTest < ActiveSupport::TestCase
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Omniauthable.required_fields(User), []
+    assert_equal Devise::Models::Omniauthable.required_fields(User), []
   end
 end

data/test/models/recoverable_test.rb

@@ -92,14 +92,14 @@ class RecoverableTest < ActiveSupport::TestCase
     user = create_user
     user.send_reset_password_instructions
     assert_present user.reset_password_token
-    assert_not user.reset_password('123456789', '987654321')
+    refute user.reset_password('123456789', '987654321')
     assert_present user.reset_password_token
   end
 
   test 'should not reset password with invalid data' do
     user = create_user
     user.stubs(:valid?).returns(false)
-    assert_not user.reset_password('123456789', '987654321')
+    refute user.reset_password('123456789', '987654321')
   end
 
   test 'should reset reset password token and send instructions by email' do
@@ -119,7 +119,7 @@ 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@example.com")
-    assert_not reset_password_user.persisted?
+    refute reset_password_user.persisted?
     assert_equal "not found", reset_password_user.errors[:email].join
   end
 
@@ -135,7 +135,7 @@ class RecoverableTest < ActiveSupport::TestCase
       swap Devise, reset_password_keys: [:username, :email] do
           user = create_user
           reset_password_user = User.send_reset_password_instructions(email: user.email)
-          assert_not reset_password_user.persisted?
+          refute reset_password_user.persisted?
           assert_equal "can't be blank", reset_password_user.errors[:username].join
       end
   end
@@ -164,13 +164,13 @@ class RecoverableTest < ActiveSupport::TestCase
 
   test 'should return 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_not reset_password_user.persisted?
+    refute reset_password_user.persisted?
     assert_equal "is invalid", reset_password_user.errors[:reset_password_token].join
   end
 
   test 'should return a new record with errors if reset_password_token is blank' do
     reset_password_user = User.reset_password_by_token(reset_password_token: '')
-    assert_not reset_password_user.persisted?
+    refute reset_password_user.persisted?
     assert_match "can't be blank", reset_password_user.errors[:reset_password_token].join
   end
 
@@ -179,7 +179,7 @@ class RecoverableTest < ActiveSupport::TestCase
     raw  = user.send_reset_password_instructions
 
     reset_password_user = User.reset_password_by_token(reset_password_token: raw, password: '')
-    assert_not reset_password_user.errors.empty?
+    refute reset_password_user.errors.empty?
     assert_match "can't be blank", reset_password_user.errors[:password].join
     assert_equal raw, reset_password_user.reset_password_token
   end
@@ -197,7 +197,7 @@ class RecoverableTest < ActiveSupport::TestCase
     assert_nil reset_password_user.reset_password_token
 
     user.reload
-    assert_not user.valid_password?(old_password)
+    refute user.valid_password?(old_password)
     assert user.valid_password?('new_password')
     assert_nil user.reset_password_token
   end
@@ -219,13 +219,13 @@ class RecoverableTest < ActiveSupport::TestCase
       user.reload
 
       assert user.valid_password?(old_password)
-      assert_not user.valid_password?('new_password')
+      refute user.valid_password?('new_password')
       assert_equal "has expired, please request a new one", reset_password_user.errors[:reset_password_token].join
     end
   end
 
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Recoverable.required_fields(User), [
+    assert_equal Devise::Models::Recoverable.required_fields(User), [
       :reset_password_sent_at,
       :reset_password_token
     ]

data/test/models/registerable_test.rb

@@ -2,6 +2,6 @@ require 'test_helper'
 
 class RegisterableTest < ActiveSupport::TestCase
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Registerable.required_fields(User), []
+    assert_equal Devise::Models::Registerable.required_fields(User), []
   end
 end

data/test/models/rememberable_test.rb

@@ -99,15 +99,28 @@ class RememberableTest < ActiveSupport::TestCase
     assert_nil User.serialize_from_cookie(user.to_key, "123", Time.now.utc)
   end
 
+  test 'raises a RuntimeError if the user does not implements a rememberable value' do
+    user = User.new
+    assert_raise(RuntimeError) { user.rememberable_value }
+
+    user_with_remember_token = User.new
+    def user_with_remember_token.remember_token; '123-token'; end
+    assert_equal '123-token', user_with_remember_token.rememberable_value
+
+    user_with_salt = User.new
+    def user_with_salt.authenticatable_salt; '123-salt'; end
+    assert_equal '123-salt', user_with_salt.rememberable_value
+  end
+
   test 'raises a RuntimeError if authenticatable_salt is nil or empty' do
     user = User.new
-    def user.authenticable_salt; nil; end
+    def user.authenticatable_salt; nil; end
     assert_raise RuntimeError do
       user.rememberable_value
     end
 
     user = User.new
-    def user.authenticable_salt; ""; end
+    def user.authenticatable_salt; ""; end
     assert_raise RuntimeError do
       user.rememberable_value
     end
@@ -162,7 +175,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'should have the required_fields array' do
-    assert_same_content Devise::Models::Rememberable.required_fields(User), [
+    assert_equal Devise::Models::Rememberable.required_fields(User), [
       :remember_created_at
     ]
   end

data/test/models/serializable_test.rb

@@ -35,6 +35,11 @@ class SerializableTest < ActiveSupport::TestCase
     assert_key "confirmation_token", from_json(force_except: :email)
   end
 
+  test 'should not include unsafe keys in inspect' do
+    assert_match(/email/, @user.inspect)
+    assert_no_match(/confirmation_token/, @user.inspect)
+  end
+
   def assert_key(key, subject)
     assert subject.key?(key), "Expected #{subject.inspect} to have key #{key.inspect}"
   end

data/test/models/timeoutable_test.rb

@@ -7,11 +7,11 @@ class TimeoutableTest < ActiveSupport::TestCase
   end
 
   test 'should not be expired' do
-    assert_not new_user.timedout?(29.minutes.ago)
+    refute new_user.timedout?(29.minutes.ago)
   end
 
   test 'should not be expired when params is nil' do
-    assert_not new_user.timedout?(nil)
+    refute new_user.timedout?(nil)
   end
 
   test 'should use timeout_in method' do
@@ -19,29 +19,29 @@ class TimeoutableTest < ActiveSupport::TestCase
     user.instance_eval { def timeout_in; 10.minutes end }
 
     assert user.timedout?(12.minutes.ago)
-    assert_not user.timedout?(8.minutes.ago)
+    refute user.timedout?(8.minutes.ago)
   end
 
   test 'should not be expired when timeout_in method returns nil' do
     user = new_user
     user.instance_eval { def timeout_in; nil end }
-    assert_not user.timedout?(10.hours.ago)
+    refute user.timedout?(10.hours.ago)
   end
 
   test 'fallback to Devise config option' do
     swap Devise, timeout_in: 1.minute do
       user = new_user
       assert user.timedout?(2.minutes.ago)
-      assert_not user.timedout?(30.seconds.ago)
+      refute user.timedout?(30.seconds.ago)
 
       Devise.timeout_in = 5.minutes
-      assert_not user.timedout?(2.minutes.ago)
+      refute user.timedout?(2.minutes.ago)
       assert user.timedout?(6.minutes.ago)
     end
   end
 
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Timeoutable.required_fields(User), []
+    assert_equal Devise::Models::Timeoutable.required_fields(User), []
   end
 
   test 'should not raise error if remember_created_at is not empty and rememberable is disabled' do

data/test/models/trackable_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 
 class TrackableTest < ActiveSupport::TestCase
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Trackable.required_fields(User), [
+    assert_equal Devise::Models::Trackable.required_fields(User), [
       :current_sign_in_at,
       :current_sign_in_ip,
       :last_sign_in_at,

data/test/models/validatable_test.rb

@@ -97,7 +97,7 @@ class ValidatableTest < ActiveSupport::TestCase
 
     user.password_confirmation = 'confirmation'
     assert user.invalid?
-    assert_not (user.errors[:password].join =~ /is too long/)
+    refute (user.errors[:password].join =~ /is too long/)
   end
 
   test 'should complain about length even if password is not required' do

data/test/models_test.rb

@@ -13,7 +13,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
     end
 
     (Devise::ALL - modules).each do |mod|
-      assert_not include_module?(klass, mod)
+      refute include_module?(klass, mod)
     end
   end
 
@@ -112,7 +112,7 @@ class CheckFieldsTest < ActiveSupport::TestCase
       attr_accessor :encrypted_password, :email
     end
 
-    assert_nothing_raised Devise::Models::MissingAttribute do
+    assert_nothing_raised do
       Devise::Models.check_fields!(Player)
     end
   end