devise 3.2.3 → 3.2.4

data/test/models/database_authenticatable_test.rb

@@ -6,7 +6,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should downcase case insensitive keys when saving' do
     # case_insensitive_keys is set to :email by default.
     email = 'Foo@Bar.com'
-    user = new_user(:email => email)
+    user = new_user(email: email)
 
     assert_equal email, user.email
     user.save!
@@ -16,7 +16,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should downcase case insensitive keys that refer to virtual attributes when saving' do
     email        = 'Foo@Bar1.com'
     confirmation = 'Foo@Bar1.com'
-    attributes   = valid_attributes(:email => email, :email_confirmation => confirmation)
+    attributes   = valid_attributes(email: email, email_confirmation: confirmation)
     user = UserWithVirtualAttributes.new(attributes)
 
     assert_equal confirmation, user.email_confirmation
@@ -27,7 +27,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should not mutate value assigned to case insensitive key' do
     email          = 'Foo@Bar.com'
     original_email = email.dup
-    user           = new_user(:email => email)
+    user           = new_user(email: email)
 
     user.save!
     assert_equal original_email, email
@@ -36,7 +36,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should remove whitespace from strip whitespace keys when saving' do
     # strip_whitespace_keys is set to :email by default.
     email = ' foo@bar.com '
-    user = new_user(:email => email)
+    user = new_user(email: email)
 
     assert_equal email, user.email
     user.save!
@@ -46,20 +46,20 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   test 'should not mutate value assigned to string whitespace key' do
     email          = ' foo@bar.com '
     original_email = email.dup
-    user           = new_user(:email => email)
+    user           = new_user(email: email)
 
     user.save!
     assert_equal original_email, email
   end
 
   test "doesn't throw exception when globally configured strip_whitespace_keys are not present on a model" do
-    swap Devise, :strip_whitespace_keys => [:fake_key] do
+    swap Devise, strip_whitespace_keys: [:fake_key] do
       assert_nothing_raised { create_user }
     end
   end
 
   test "doesn't throw exception when globally configured case_insensitive_keys are not present on a model" do
-    swap Devise, :case_insensitive_keys => [:fake_key] do
+    swap Devise, case_insensitive_keys: [:fake_key] do
       assert_nothing_raised { create_user }
     end
   end
@@ -94,7 +94,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   end
 
   test 'should support custom encryption methods' do
-    user = UserWithCustomEncryption.new(:password => '654321')
+    user = UserWithCustomEncryption.new(password: '654321')
     assert_equal user.encrypted_password, '123456'
   end
 
@@ -105,8 +105,8 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   end
 
   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
+    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
@@ -141,23 +141,23 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
 
   test 'should update password with valid current password' do
     user = create_user
-    assert user.update_with_password(:current_password => '12345678',
-      :password => 'pass4321', :password_confirmation => 'pass4321')
+    assert user.update_with_password(current_password: '12345678',
+      password: 'pass4321', password_confirmation: 'pass4321')
     assert user.reload.valid_password?('pass4321')
   end
 
   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',
-      :password => 'pass4321', :password_confirmation => 'pass4321')
+    assert_not 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
   end
 
   test 'should add an error to current password when it is blank' do
     user = create_user
-    assert_not user.update_with_password(:password => 'pass4321',
-      :password_confirmation => 'pass4321')
+    assert_not 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
   end
@@ -166,41 +166,41 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
     user = UserWithValidation.create!(valid_attributes)
     user.save
     assert user.persisted?
-    assert_not user.update_with_password(:username => "")
+    assert_not user.update_with_password(username: "")
     assert_match "usertest", user.reload.username
     assert_match "can't be blank", user.errors[:username].join
   end
 
   test 'should ignore password and its confirmation if they are blank' do
     user = create_user
-    assert user.update_with_password(:current_password => '12345678', :email => "new@example.com")
+    assert user.update_with_password(current_password: '12345678', email: "new@example.com")
     assert_equal "new@example.com", user.email
   end
 
   test 'should not update password with invalid confirmation' do
     user = create_user
-    assert_not user.update_with_password(:current_password => '12345678',
-      :password => 'pass4321', :password_confirmation => 'other')
+    assert_not 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',
-      :password => 'pass4321', :password_confirmation => 'other')
+    assert_not user.update_with_password(current_password: '12345678',
+      password: 'pass4321', password_confirmation: 'other')
     assert user.password.blank?
     assert user.password_confirmation.blank?
   end
 
   test 'should update the user without password' do
     user = create_user
-    user.update_without_password(:email => 'new@example.com')
+    user.update_without_password(email: 'new@example.com')
     assert_equal 'new@example.com', user.email
   end
 
   test 'should not update password without password' do
     user = create_user
-    user.update_without_password(:password => 'pass4321', :password_confirmation => 'pass4321')
+    user.update_without_password(password: 'pass4321', password_confirmation: 'pass4321')
     assert !user.reload.valid_password?('pass4321')
     assert user.valid_password?('12345678')
   end
@@ -226,8 +226,8 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   end
 
   test 'downcase_keys with validation' do
-    User.create(:email => "HEllO@example.com", :password => "123456")
-    user = User.create(:email => "HEllO@example.com", :password => "123456")
+    User.create(email: "HEllO@example.com", password: "123456")
+    user = User.create(email: "HEllO@example.com", password: "123456")
     assert !user.valid?
   end
 
@@ -239,7 +239,7 @@ class DatabaseAuthenticatableTest < ActiveSupport::TestCase
   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
+    swap Devise, authentication_keys: [:login] do
       assert_same_content Devise::Models::DatabaseAuthenticatable.required_fields(User), [
         :encrypted_password,
         :login

data/test/models/lockable_test.rb

@@ -8,7 +8,7 @@ class LockableTest < ActiveSupport::TestCase
   test "should respect maximum attempts configuration" do
     user = create_user
     user.confirm!
-    swap Devise, :maximum_attempts => 2 do
+    swap Devise, maximum_attempts: 2 do
       2.times { user.valid_for_authentication?{ false } }
       assert user.reload.access_locked?
     end
@@ -18,7 +18,7 @@ class LockableTest < ActiveSupport::TestCase
     user = create_user
     user.confirm!
 
-    swap Devise, :maximum_attempts => 2 do
+    swap Devise, maximum_attempts: 2 do
       2.times { user.valid_for_authentication?{ false } }
       assert user.reload.access_locked?
     end
@@ -30,7 +30,7 @@ class LockableTest < ActiveSupport::TestCase
   test "should not touch failed_attempts if lock_strategy is none" do
     user = create_user
     user.confirm!
-    swap Devise, :lock_strategy => :none, :maximum_attempts => 2 do
+    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
@@ -77,7 +77,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "should unlock user after unlock_in period" do
-    swap Devise, :unlock_in => 3.hours do
+    swap Devise, unlock_in: 3.hours do
       user = new_user
       user.locked_at = 2.hours.ago
       assert user.access_locked?
@@ -88,7 +88,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "should not unlock in 'unlock_in' if :time unlock strategy is not set" do
-    swap Devise, :unlock_strategy => :email do
+    swap Devise, unlock_strategy: :email do
       user = new_user
       user.locked_at = 2.hours.ago
       assert user.access_locked?
@@ -114,7 +114,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "should not generate unlock_token when :email is not an unlock strategy" do
-    swap Devise, :unlock_strategy => :time do
+    swap Devise, unlock_strategy: :time do
       user = create_user
       user.lock_access!
       assert_nil user.unlock_token
@@ -122,7 +122,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "should send email with unlock instructions when :email is an unlock strategy" do
-    swap Devise, :unlock_strategy => :email do
+    swap Devise, unlock_strategy: :email do
       user = create_user
       assert_email_sent do
         user.lock_access!
@@ -131,7 +131,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "doesn't send email when you pass option send_instructions to false" do
-    swap Devise, :unlock_strategy => :email do
+    swap Devise, unlock_strategy: :email do
       user = create_user
       assert_email_not_sent do
         user.lock_access! send_instructions: false
@@ -140,7 +140,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "sends email when you pass options other than send_instructions" do
-    swap Devise, :unlock_strategy => :email do
+    swap Devise, unlock_strategy: :email do
       user = create_user
       assert_email_sent do
         user.lock_access! foo: :bar, bar: :foo
@@ -149,7 +149,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test "should not send email with unlock instructions when :email is not an unlock strategy" do
-    swap Devise, :unlock_strategy => :time do
+    swap Devise, unlock_strategy: :time do
       user = create_user
       assert_email_not_sent do
         user.lock_access!
@@ -180,32 +180,32 @@ class LockableTest < ActiveSupport::TestCase
   test 'should find a user to send unlock instructions' do
     user = create_user
     user.lock_access!
-    unlock_user = User.send_unlock_instructions(:email => user.email)
+    unlock_user = User.send_unlock_instructions(email: user.email)
     assert_equal unlock_user, user
   end
 
   test 'should return a new user if no email was found' do
-    unlock_user = User.send_unlock_instructions(:email => "invalid@example.com")
+    unlock_user = User.send_unlock_instructions(email: "invalid@example.com")
     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@example.com")
+    unlock_user = User.send_unlock_instructions(email: "invalid@example.com")
     assert_equal 'not found', unlock_user.errors[:email].join
   end
 
   test 'should find a user to send unlock instructions by authentication_keys' do
-    swap Devise, :authentication_keys => [:username, :email] do
+    swap Devise, authentication_keys: [:username, :email] do
       user = create_user
-      unlock_user = User.send_unlock_instructions(:email => user.email, :username => user.username)
+      unlock_user = User.send_unlock_instructions(email: user.email, username: user.username)
       assert_equal unlock_user, user
     end
   end
 
   test 'should require all unlock_keys' do
-    swap Devise, :unlock_keys => [:username, :email] do
+    swap Devise, unlock_keys: [:username, :email] do
       user = create_user
-      unlock_user = User.send_unlock_instructions(:email => user.email)
+      unlock_user = User.send_unlock_instructions(email: user.email)
       assert_not unlock_user.persisted?
       assert_equal "can't be blank", unlock_user.errors[:username].join
     end
@@ -219,7 +219,7 @@ class LockableTest < ActiveSupport::TestCase
   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
+    swap Devise, unlock_keys: [:username] do
       user = create_user
       assert_not user.resend_unlock_instructions
       assert_not user.access_locked?
@@ -228,7 +228,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test 'should unlock account if lock has expired and increase attempts on failure' do
-    swap Devise, :unlock_in => 1.minute do
+    swap Devise, unlock_in: 1.minute do
       user = create_user
       user.confirm!
 
@@ -241,7 +241,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test 'should unlock account if lock has expired on success' do
-    swap Devise, :unlock_in => 1.minute do
+    swap Devise, unlock_in: 1.minute do
       user = create_user
       user.confirm!
 
@@ -255,8 +255,8 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   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
+    swap Devise, unlock_strategy: :both do
+      swap Devise, lock_strategy: :failed_attempts do
         assert_same_content Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :locked_at,
@@ -267,8 +267,8 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   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
+    swap Devise, unlock_strategy: :time do
+      swap Devise, lock_strategy: :failed_attempts do
         assert_same_content Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :locked_at
@@ -278,8 +278,8 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   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
+    swap Devise, unlock_strategy: :email do
+      swap Devise, lock_strategy: :failed_attempts do
         assert_same_content Devise::Models::Lockable.required_fields(User), [
          :failed_attempts,
          :unlock_token
@@ -289,7 +289,7 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test 'should not return a locked unauthenticated message if in paranoid mode' do
-    swap Devise, :paranoid => :true do
+    swap Devise, paranoid: :true do
       user = create_user
       user.failed_attempts = Devise.maximum_attempts + 1
       user.lock_access!
@@ -299,8 +299,8 @@ class LockableTest < ActiveSupport::TestCase
   end
 
   test 'should return last attempt message if user made next-to-last attempt of password entering' do
-    swap Devise, :last_attempt_warning => :true do
-      swap Devise, :lock_strategy => :failed_attempts do
+    swap Devise, last_attempt_warning: :true do
+      swap Devise, lock_strategy: :failed_attempts do
         user = create_user
         user.failed_attempts = Devise.maximum_attempts - 2
         assert_equal :invalid, user.unauthenticated_message

data/test/models/recoverable_test.rb

@@ -67,28 +67,28 @@ 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)
+    reset_password_user = User.send_reset_password_instructions(email: user.email)
     assert_equal reset_password_user, user
   end
 
   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")
+    reset_password_user = User.send_reset_password_instructions(email: "invalid@example.com")
     assert_not reset_password_user.persisted?
     assert_equal "not found", reset_password_user.errors[:email].join
   end
 
   test 'should find a user to send instructions by authentication_keys' do
-    swap Devise, :authentication_keys => [:username, :email] do
+    swap Devise, authentication_keys: [:username, :email] do
       user = create_user
-      reset_password_user = User.send_reset_password_instructions(:email => user.email, :username => user.username)
+      reset_password_user = User.send_reset_password_instructions(email: user.email, username: user.username)
       assert_equal reset_password_user, user
     end
   end
 
   test 'should require all reset_password_keys' do
-      swap Devise, :reset_password_keys => [:username, :email] do
+      swap Devise, reset_password_keys: [:username, :email] do
           user = create_user
-          reset_password_user = User.send_reset_password_instructions(:email => user.email)
+          reset_password_user = User.send_reset_password_instructions(email: user.email)
           assert_not reset_password_user.persisted?
           assert_equal "can't be blank", reset_password_user.errors[:username].join
       end
@@ -97,14 +97,14 @@ class RecoverableTest < ActiveSupport::TestCase
   test 'should reset reset_password_token before send the reset instructions email' do
     user = create_user
     token = user.reset_password_token
-    User.send_reset_password_instructions(:email => user.email)
+    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 their password' do
     user = create_user
     assert_email_sent do
-      User.send_reset_password_instructions(:email => user.email)
+      User.send_reset_password_instructions(email: user.email)
     end
   end
 
@@ -112,18 +112,18 @@ class RecoverableTest < ActiveSupport::TestCase
     user = create_user
     raw  = user.send_reset_password_instructions
 
-    reset_password_user = User.reset_password_by_token(:reset_password_token => raw)
+    reset_password_user = User.reset_password_by_token(reset_password_token: raw)
     assert_equal reset_password_user, user
   end
 
   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')
+    reset_password_user = User.reset_password_by_token(reset_password_token: 'invalid_token')
     assert_not 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 => '')
+    reset_password_user = User.reset_password_by_token(reset_password_token: '')
     assert_not reset_password_user.persisted?
     assert_match "can't be blank", reset_password_user.errors[:reset_password_token].join
   end
@@ -132,7 +132,7 @@ class RecoverableTest < ActiveSupport::TestCase
     user = create_user
     raw  = user.send_reset_password_instructions
 
-    reset_password_user = User.reset_password_by_token(:reset_password_token => raw, :password => '')
+    reset_password_user = User.reset_password_by_token(reset_password_token: raw, password: '')
     assert_not reset_password_user.errors.empty?
     assert_match "can't be blank", reset_password_user.errors[:password].join
   end
@@ -143,9 +143,9 @@ class RecoverableTest < ActiveSupport::TestCase
     raw  = user.send_reset_password_instructions
 
     User.reset_password_by_token(
-      :reset_password_token => raw,
-      :password => 'new_password',
-      :password_confirmation => 'new_password'
+      reset_password_token: raw,
+      password: 'new_password',
+      password_confirmation: 'new_password'
     )
     user.reload
 
@@ -154,7 +154,7 @@ class RecoverableTest < ActiveSupport::TestCase
   end
 
   test 'should not reset password after reset_password_within time' do
-    swap Devise, :reset_password_within => 1.hour do
+    swap Devise, reset_password_within: 1.hour do
       user = create_user
       raw  = user.send_reset_password_instructions
 
@@ -163,9 +163,9 @@ class RecoverableTest < ActiveSupport::TestCase
       user.save!
 
       reset_password_user = User.reset_password_by_token(
-        :reset_password_token => raw,
-        :password => 'new_password',
-        :password_confirmation => 'new_password'
+        reset_password_token: raw,
+        password: 'new_password',
+        password_confirmation: 'new_password'
       )
       user.reload