devise 3.2.0 → 3.3.0

data/test/models/lockable_test.rb

@@ -8,8 +8,8 @@ class LockableTest < ActiveSupport::TestCase
   test "should respect maximum attempts configuration" do
     user = create_user
     user.confirm!
-    swap Devise, :maximum_attempts => 2 do
-      3.times { user.valid_for_authentication?{ false } }
+    swap Devise, maximum_attempts: 2 do
+      2.times { user.valid_for_authentication?{ false } }
       assert user.reload.access_locked?
     end
   end
@@ -18,19 +18,19 @@ class LockableTest < ActiveSupport::TestCase
     user = create_user
     user.confirm!
 
-    swap Devise, :maximum_attempts => 2 do
-      3.times { user.valid_for_authentication?{ false } }
+    swap Devise, maximum_attempts: 2 do
+      2.times { user.valid_for_authentication?{ false } }
       assert user.reload.access_locked?
     end
 
     user.valid_for_authentication?{ true }
-    assert_equal 4, user.reload.failed_attempts
+    assert_equal 3, user.reload.failed_attempts
   end
 
   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!
@@ -130,8 +130,26 @@ class LockableTest < ActiveSupport::TestCase
     end
   end
 
+  test "doesn't send email when you pass option send_instructions to false" do
+    swap Devise, unlock_strategy: :email do
+      user = create_user
+      assert_email_not_sent do
+        user.lock_access! send_instructions: false
+      end
+    end
+  end
+
+  test "sends email when you pass options other than send_instructions" do
+    swap Devise, unlock_strategy: :email do
+      user = create_user
+      assert_email_sent do
+        user.lock_access! foo: :bar, bar: :foo
+      end
+    end
+  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!
@@ -162,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
@@ -201,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?
@@ -210,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!
 
@@ -223,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!
 
@@ -237,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,
@@ -249,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
@@ -260,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
@@ -271,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!
@@ -281,18 +299,24 @@ 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 - 1
+        user.failed_attempts = Devise.maximum_attempts - 2
         assert_equal :invalid, user.unauthenticated_message
 
-        user.failed_attempts = Devise.maximum_attempts
+        user.failed_attempts = Devise.maximum_attempts - 1
         assert_equal :last_attempt, user.unauthenticated_message
 
-        user.failed_attempts = Devise.maximum_attempts + 1
+        user.failed_attempts = Devise.maximum_attempts
         assert_equal :locked, user.unauthenticated_message
       end
     end
   end
+
+  test 'should return locked message if user was programatically locked' do
+    user = create_user
+    user.lock_access!
+    assert_equal :locked, user.unauthenticated_message
+  end
 end

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,33 +97,33 @@ 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 his password' do
+  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
 
-  test 'should find a user to reset his password based on the raw token' do
+  test 'should find a user to reset their password based on the raw token' do
     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
 
@@ -180,5 +180,17 @@ class RecoverableTest < ActiveSupport::TestCase
       :reset_password_sent_at,
       :reset_password_token
     ]
-  end  
+  end
+
+  test 'should return a user based on the raw token' do
+    user = create_user
+    raw  = user.send_reset_password_instructions
+
+    assert_equal User.with_reset_password_token(raw), user
+  end
+
+  test 'should return nil if a user based on the raw token is not found' do
+    assert_equal User.with_reset_password_token('random-token'), nil
+  end
+
 end

data/test/models/rememberable_test.rb

@@ -55,12 +55,27 @@ class RememberableTest < ActiveSupport::TestCase
     assert resource_class.new.respond_to?(:remember_me=)
   end
 
-  test 'forget_me should clear remember_created_at' do
-    resource = create_resource
-    resource.remember_me!
-    assert_not resource.remember_created_at.nil?
-    resource.forget_me!
-    assert resource.remember_created_at.nil?
+  test 'forget_me should clear remember_created_at if expire_all_remember_me_on_sign_out is true' do
+    swap Devise, expire_all_remember_me_on_sign_out: true do
+      resource = create_resource
+      resource.remember_me!
+      assert_not_nil resource.remember_created_at
+
+      resource.forget_me!
+      assert_nil resource.remember_created_at
+    end
+  end
+
+  test 'forget_me should not clear remember_created_at if expire_all_remember_me_on_sign_out is false' do
+    swap Devise, expire_all_remember_me_on_sign_out: false do
+      resource = create_resource
+      resource.remember_me!
+
+      assert_not_nil resource.remember_created_at
+
+      resource.forget_me!
+      assert_not_nil resource.remember_created_at
+    end
   end
 
   test 'forget_me should not try to update resource if it has been destroyed' do
@@ -86,7 +101,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember for should fallback to devise remember for default configuration' do
-    swap Devise, :remember_for => 1.day do
+    swap Devise, remember_for: 1.day do
       resource = create_resource
       resource.remember_me!
       assert_not resource.remember_expired?
@@ -94,7 +109,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember expires at should sum date of creation with remember for configuration' do
-    swap Devise, :remember_for => 3.days do
+    swap Devise, remember_for: 3.days do
       resource = create_resource
       resource.remember_me!
       assert_equal 3.days.from_now.to_date, resource.remember_expires_at.to_date
@@ -105,7 +120,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember should be expired if remember_for is zero' do
-    swap Devise, :remember_for => 0.days do
+    swap Devise, remember_for: 0.days do
       Devise.remember_for = 0.days
       resource = create_resource
       resource.remember_me!
@@ -114,7 +129,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember should be expired if it was created before limit time' do
-    swap Devise, :remember_for => 1.day do
+    swap Devise, remember_for: 1.day do
       resource = create_resource
       resource.remember_me!
       resource.remember_created_at = 2.days.ago
@@ -124,7 +139,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'remember should not be expired if it was created within the limit time' do
-    swap Devise, :remember_for => 30.days do
+    swap Devise, remember_for: 30.days do
       resource = create_resource
       resource.remember_me!
       resource.remember_created_at = (30.days.ago + 2.minutes)
@@ -134,7 +149,7 @@ class RememberableTest < ActiveSupport::TestCase
   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
+    swap Devise, remember_for: 5.minutes do
       resource = create_resource
       resource.remember_me!(false)
       assert resource.remember_created_at
@@ -148,7 +163,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'if extend_remember_period is false, remember_me! should not generate a new timestamp' do
-    swap Devise, :remember_for => 1.year do
+    swap Devise, remember_for: 1.year do
       resource = create_resource
       resource.remember_me!(false)
       assert resource.remember_created_at
@@ -162,7 +177,7 @@ class RememberableTest < ActiveSupport::TestCase
   end
 
   test 'if extend_remember_period is true, remember_me! should always generate a new timestamp' do
-    swap Devise, :remember_for => 1.year do
+    swap Devise, remember_for: 1.year do
       resource = create_resource
       resource.remember_me!(true)
       assert resource.remember_created_at

data/test/models/serializable_test.rb

@@ -11,13 +11,13 @@ class SerializableTest < ActiveSupport::TestCase
   end
 
   test 'should not include unsafe keys on XML even if a new except is provided' do
-    assert_no_match(/email/, @user.to_xml(:except => :email))
-    assert_no_match(/confirmation-token/, @user.to_xml(:except => :email))
+    assert_no_match(/email/, @user.to_xml(except: :email))
+    assert_no_match(/confirmation-token/, @user.to_xml(except: :email))
   end
 
   test 'should include unsafe keys on XML if a force_except is provided' do
-    assert_no_match(/<email/, @user.to_xml(:force_except => :email))
-    assert_match(/confirmation-token/, @user.to_xml(:force_except => :email))
+    assert_no_match(/<email/, @user.to_xml(force_except: :email))
+    assert_match(/confirmation-token/, @user.to_xml(force_except: :email))
   end
 
   test 'should not include unsafe keys on JSON' do
@@ -26,13 +26,13 @@ class SerializableTest < ActiveSupport::TestCase
   end
 
   test 'should not include unsafe keys on JSON even if a new except is provided' do
-    assert_no_key "email", from_json(:except => :email)
-    assert_no_key "confirmation_token", from_json(:except => :email)
+    assert_no_key "email", from_json(except: :email)
+    assert_no_key "confirmation_token", from_json(except: :email)
   end
 
   test 'should include unsafe keys on JSON if a force_except is provided' do
-    assert_no_key "email", from_json(:force_except => :email)
-    assert_key "confirmation_token", from_json(:force_except => :email)
+    assert_no_key "email", from_json(force_except: :email)
+    assert_key "confirmation_token", from_json(force_except: :email)
   end
 
   def assert_key(key, subject)

data/test/models/timeoutable_test.rb

@@ -29,7 +29,7 @@ class TimeoutableTest < ActiveSupport::TestCase
   end
 
   test 'fallback to Devise config option' do
-    swap Devise, :timeout_in => 1.minute do
+    swap Devise, timeout_in: 1.minute do
       user = new_user
       assert user.timedout?(2.minutes.ago)
       assert_not user.timedout?(30.seconds.ago)

data/test/models/trackable_test.rb

@@ -10,4 +10,32 @@ class TrackableTest < ActiveSupport::TestCase
       :sign_in_count
     ]
   end
+
+  test 'update_tracked_fields should only set attributes but not save the record' do
+    user = create_user
+    request = mock
+    request.stubs(:remote_ip).returns("127.0.0.1")
+
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+    assert_equal 0, user.sign_in_count
+
+    user.update_tracked_fields(request)
+
+    assert_equal "127.0.0.1", user.current_sign_in_ip
+    assert_equal "127.0.0.1", user.last_sign_in_ip
+    assert_not_nil user.current_sign_in_at
+    assert_not_nil user.last_sign_in_at
+    assert_equal 1, user.sign_in_count
+
+    user.reload
+
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+    assert_equal 0, user.sign_in_count
+  end
 end

data/test/models/validatable_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 
 class ValidatableTest < ActiveSupport::TestCase
   test 'should require email to be set' do
-    user = new_user(:email => nil)
+    user = new_user(email: nil)
     assert user.invalid?
     assert user.errors[:email]
     assert_equal 'can\'t be blank', user.errors[:email].join
@@ -12,7 +12,7 @@ class ValidatableTest < ActiveSupport::TestCase
   test 'should require uniqueness of email if email has changed, allowing blank' do
     existing_user = create_user
 
-    user = new_user(:email => '')
+    user = new_user(email: '')
     assert user.invalid?
     assert_no_match(/taken/, user.errors[:email].join)
 
@@ -20,12 +20,12 @@ class ValidatableTest < ActiveSupport::TestCase
     assert user.invalid?
     assert_match(/taken/, user.errors[:email].join)
 
-    user.save(:validate => false)
+    user.save(validate: false)
     assert user.valid?
   end
 
   test 'should require correct email format if email has changed, allowing blank' do
-    user = new_user(:email => '')
+    user = new_user(email: '')
     assert user.invalid?
     assert_not_equal 'is invalid', user.errors[:email].join
 
@@ -35,26 +35,26 @@ class ValidatableTest < ActiveSupport::TestCase
       assert_equal 'is invalid', user.errors[:email].join
     end
 
-    user.save(:validate => false)
+    user.save(validate: false)
     assert user.valid?
   end
 
   test 'should accept valid emails' do
     %w(a.b.c@example.com test_mail@gmail.com any@any.net email@test.br 123@mail.test 1☃3@mail.test).each do |email|
-      user = new_user(:email => email)
+      user = new_user(email: email)
       assert user.valid?, 'should be valid with email ' << 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 => '')
+    user = new_user(password: '', password_confirmation: '')
     assert user.invalid?
     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')
+    user = new_user(password: 'new_password', password_confirmation: 'blabla')
     assert user.invalid?
 
     if Devise.rails4?
@@ -86,14 +86,14 @@ class ValidatableTest < ActiveSupport::TestCase
     end
   end
 
-  test 'should require a password with minimum of 6 characters' do
-    user = new_user(:password => '12345', :password_confirmation => '12345')
+  test 'should require a password with minimum of 7 characters' do
+    user = new_user(password: '12345', password_confirmation: '12345')
     assert user.invalid?
-    assert_equal 'is too short (minimum is 6 characters)', user.errors[:password].join
+    assert_equal 'is too short (minimum is 7 characters)', user.errors[:password].join
   end
 
   test 'should require a password with maximum of 128 characters long' do
-    user = new_user(:password => 'x'*129, :password_confirmation => 'x'*129)
+    user = new_user(password: 'x'*129, password_confirmation: 'x'*129)
     assert user.invalid?
     assert_equal 'is too long (maximum is 128 characters)', user.errors[:password].join
   end
@@ -109,7 +109,7 @@ class ValidatableTest < ActiveSupport::TestCase
   end
 
   test 'should complain about length even if password is not required' do
-    user = new_user(:password => 'x'*129, :password_confirmation => 'x'*129)
+    user = new_user(password: 'x'*129, password_confirmation: 'x'*129)
     user.stubs(:password_required?).returns(false)
     assert user.invalid?
     assert_equal 'is too long (maximum is 128 characters)', user.errors[:password].join

data/test/omniauth/config_test.rb

@@ -11,12 +11,12 @@ class OmniAuthConfigTest < ActiveSupport::TestCase
   end
 
   test 'strategy_name returns provider if no name option are given' do
-    config = Devise::OmniAuth::Config.new :facebook, [{ :other => :option }]
+    config = Devise::OmniAuth::Config.new :facebook, [{ other: :option }]
     assert_equal :facebook, config.strategy_name
   end
 
   test 'returns name option when have a name' do
-    config = Devise::OmniAuth::Config.new :facebook, [{ :name => :github }]
+    config = Devise::OmniAuth::Config.new :facebook, [{ name: :github }]
     assert_equal :github, config.strategy_name
   end
 
@@ -50,8 +50,8 @@ class OmniAuthConfigTest < ActiveSupport::TestCase
   end
 
   test 'allows the user to define a custom require path' do
-    config = Devise::OmniAuth::Config.new :my_strategy, [{:strategy_class => MyStrategy}]
+    config = Devise::OmniAuth::Config.new :my_strategy, [{strategy_class: MyStrategy}]
     config_class = config.strategy_class
     assert_equal MyStrategy, config_class
   end
-end
+end