devise_invitable 1.7.5 → 2.0.5

data/test/model_tests_helper.rb

@@ -21,13 +21,13 @@ class ActiveSupport::TestCase
     "test#{@@email_count}@email.com"
   end
 
-  def valid_attributes(attributes={})
-    { :email => generate_unique_email,
-      :password => '123456',
-      :password_confirmation => '123456' }.update(attributes)
+  def valid_attributes(attributes = {})
+    { email: generate_unique_email,
+      password: '123456',
+      password_confirmation: '123456' }.update(attributes)
   end
 
-  def new_user(attributes={})
+  def new_user(attributes = {})
     User.new(valid_attributes(attributes))
   end
 

data/test/models/invitable_test.rb

@@ -1,6 +1,10 @@
 require 'test_helper'
 require 'model_tests_helper'
 
+class Validatable < User
+  devise :validatable, password_length: 10..20
+end
+
 class InvitableTest < ActiveSupport::TestCase
 
   def setup
@@ -15,7 +19,7 @@ class InvitableTest < ActiveSupport::TestCase
     if defined?(ActiveRecord)
       current_user = new_user
       2.times do |index|
-        User.invite!({:email => "valid#{index}@email.com"}, current_user)
+        User.invite!({ email: "valid#{index}@email.com" }, current_user)
       end
       assert_equal current_user.reload.invitations_count, 2
     end
@@ -74,7 +78,7 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should return the correct raw_invitation_token ' do
     user = new_user
     raw, enc = Devise.token_generator.generate(user.class, :invitation_token)
-    #stub the generator so the tokens are the same
+    # stub the generator so the tokens are the same
     Devise.token_generator.stubs(:generate).returns([raw, enc])
     user.invite!
     assert_equal user.raw_invitation_token, raw
@@ -85,17 +89,17 @@ class InvitableTest < ActiveSupport::TestCase
     user.invite!
     old_invitation_created_at = 3.days.ago
     old_invitation_sent_at = 3.days.ago
-    user.update_attributes(:invitation_sent_at => old_invitation_sent_at, :invitation_created_at => old_invitation_created_at)
+    user.update_attributes(invitation_sent_at: old_invitation_sent_at, invitation_created_at: old_invitation_created_at)
     3.times do
       user.invite!
       refute_equal old_invitation_sent_at, user.invitation_sent_at
       refute_equal old_invitation_created_at, user.invitation_created_at
-      user.update_attributes(:invitation_sent_at => old_invitation_sent_at, :invitation_created_at => old_invitation_created_at)
+      user.update_attributes(invitation_sent_at: old_invitation_sent_at, invitation_created_at: old_invitation_created_at)
     end
   end
 
   test 'should test invitation sent at with invite_for configuration value' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
 
     User.stubs(:invite_for).returns(nil)
     user.invitation_created_at = Time.now.utc
@@ -125,7 +129,7 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should return token validity when there is invite_for' do
     User.stubs(:invite_for).returns(1.day)
 
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     sent_at = user.invitation_created_at || user.invitation_sent_at
     valid_until = sent_at + User.invite_for
 
@@ -134,7 +138,7 @@ class InvitableTest < ActiveSupport::TestCase
 
   test 'should return nil for invitation due date when invite_for is nil' do
     User.stubs(:invite_for).returns(nil)
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
 
     assert_nil user.invitation_due_at
   end
@@ -158,22 +162,22 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should invite with multiple columns for invite key' do
-    User.stubs(:invite_key).returns(:email => Devise.email_regexp, :username => /\A.+\z/)
-    user = User.invite!(:email => "valid@email.com", :username => "name")
+    User.stubs(:invite_key).returns(email: Devise.email_regexp, username: /\A.+\z/)
+    user = User.invite!(email: 'valid@email.com', username: "name")
     assert_predicate user, :persisted?
     assert_empty user.errors
   end
 
   test 'should allow non-string columns for invite key' do
-    User.stubs(:invite_key).returns(:email => Devise.email_regexp, :profile_id => :present?.to_proc, :active => true)
-    user = User.invite!(:email => "valid@email.com", :profile_id => 1, :active => true)
+    User.stubs(:invite_key).returns(email: Devise.email_regexp, profile_id: :present?.to_proc)
+    user = User.invite!(email: 'valid@email.com', profile_id: 1)
     assert_predicate user, :persisted?
     assert_empty user.errors
   end
 
   test 'should not invite with some missing columns when invite key is an array' do
-    User.stubs(:invite_key).returns(:email => Devise.email_regexp, :username => /\A.+\z/, :profile_id => :present?.to_proc, :active => true)
-    user = User.invite!(:email => "valid@email.com")
+    User.stubs(:invite_key).returns(email: Devise.email_regexp, username: /\A.+\z/, profile_id: :present?.to_proc, active: true)
+    user = User.invite!(email: 'valid@email.com')
     assert_predicate user, :new_record?
     refute_empty user.errors
     assert user.errors[:username]
@@ -183,48 +187,48 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should return mail object' do
-    mail = User.invite_mail!(:email => 'valid@email.com')
+    mail = User.invite_mail!(email: 'valid@email.com')
     assert_instance_of Mail::Message, mail
   end
 
   test 'should disallow login when invited' do
-    invited_user = User.invite!(:email => "valid@email.com")
+    invited_user = User.invite!(email: 'valid@email.com')
     refute invited_user.valid_password?('1234')
   end
 
   test 'should not accept invite without password' do
-    User.invite!(:email => "valid@email.com")
-    User.accept_invitation!(:invitation_token => Thread.current[:token])
-    refute_predicate User.where(:email => 'valid@email.com').first, :invitation_accepted?
+    User.invite!(email: 'valid@email.com')
+    User.accept_invitation!(invitation_token: Thread.current[:token])
+    refute_predicate User.where(email: 'valid@email.com').first, :invitation_accepted?
   end
 
   test 'should accept invite without password if enforce is disabled' do
-    Devise.stubs(:require_password_on_accepting => false)
-    User.invite!(:email => "valid@email.com")
-    User.accept_invitation!(:invitation_token => Thread.current[:token])
-    assert_predicate User.where(:email => 'valid@email.com').first, :invitation_accepted?
+    Devise.stubs(require_password_on_accepting: false)
+    User.invite!(email: 'valid@email.com')
+    User.accept_invitation!(invitation_token: Thread.current[:token])
+    assert_predicate User.where(email: 'valid@email.com').first, :invitation_accepted?
   end
 
   test 'should set password and password confirmation from params' do
-    User.invite!(:email => "valid@email.com")
-    user = User.accept_invitation!(:invitation_token => Thread.current[:token], :password => '123456789', :password_confirmation => '123456789')
+    User.invite!(email: 'valid@email.com')
+    user = User.accept_invitation!(invitation_token: Thread.current[:token], password: '123456789', password_confirmation: '123456789')
     assert user.valid_password?('123456789')
   end
 
   test 'should set password and save the record' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     old_encrypted_password = user.encrypted_password
-    user = User.accept_invitation!(:invitation_token => Thread.current[:token], :password => '123456789', :password_confirmation => '123456789')
+    user = User.accept_invitation!(invitation_token: Thread.current[:token], password: '123456789', password_confirmation: '123456789')
     refute_equal old_encrypted_password, user.encrypted_password
   end
 
   test 'should not override password on invite!' do
-    user = User.invite!(:email => "valid@email.com", :password => 'password', :password_confirmation => 'password', :skip_invitation => true)
+    user = User.invite!(email: 'valid@email.com', password: 'password', password_confirmation: 'password', skip_invitation: true)
     assert user.valid?
   end
 
   test 'should clear invitation token and set invitation_accepted_at while accepting the password' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.invitation_token.present?
     assert_nil user.invitation_accepted_at
     user.accept_invitation!
@@ -238,11 +242,11 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should not clear invitation token or set accepted_at if record is invalid' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.invitation_token.present?
     assert_nil user.invitation_accepted_at
     old_encrypted_password = user.encrypted_password
-    User.accept_invitation!(:invitation_token => user.invitation_token, :password => '123456789', :password_confirmation => '987654321')
+    User.accept_invitation!(invitation_token: user.invitation_token, password: '123456789', password_confirmation: '987654321')
     user.reload
     assert_equal old_encrypted_password, user.encrypted_password
     assert user.invitation_token.present?
@@ -250,10 +254,10 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should not require reloading if invalid' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.invitation_token.present?
     assert_nil user.invitation_accepted_at
-    user.attributes = { :password => '123456789', :password_confirmation => '987654321' }
+    user.attributes = { password: '123456789', password_confirmation: '987654321' }
     user.accept_invitation!
     assert user.invitation_token.present?
     assert_nil user.invitation_accepted_at
@@ -261,7 +265,7 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should clear invitation token while resetting the password' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.invited_to_sign_up?
     token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
     user.reset_password_sent_at = Time.now.utc
@@ -269,14 +273,14 @@ class InvitableTest < ActiveSupport::TestCase
 
     assert user.reset_password_token.present?
     assert user.invitation_token.present?
-    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '123456789')
+    User.reset_password_by_token(reset_password_token: token, password: '123456789', password_confirmation: '123456789')
     assert_nil user.reload.reset_password_token
     assert_nil user.reload.invitation_token
     refute_predicate user, :invited_to_sign_up?
   end
 
   test 'should not accept invitation on failing to reset the password' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.invited_to_sign_up?
     token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
     user.reset_password_sent_at = Time.now.utc
@@ -284,14 +288,14 @@ class InvitableTest < ActiveSupport::TestCase
 
     assert user.reset_password_token.present?
     assert user.invitation_token.present?
-    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '12345678')
+    User.reset_password_by_token(reset_password_token: token, password: '123456789', password_confirmation: '12345678')
     assert user.reload.reset_password_token.present?
     assert user.reload.invitation_token.present?
     assert user.invited_to_sign_up?
   end
 
   test 'should not set invitation_accepted_at if just resetting password' do
-    user = User.create!(:email => "valid@email.com", :password => "123456780")
+    user = User.create!(email: 'valid@email.com', password: '123456780')
     refute_predicate user, :invited_to_sign_up?
     token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
     user.reset_password_sent_at = Time.now.utc
@@ -299,7 +303,7 @@ class InvitableTest < ActiveSupport::TestCase
 
     assert user.reset_password_token.present?
     assert_nil user.invitation_token
-    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '123456789')
+    User.reset_password_by_token(reset_password_token: token, password: '123456789', password_confirmation: '123456789')
     assert_nil user.reload.invitation_token
     assert_nil user.reload.invitation_accepted_at
   end
@@ -314,7 +318,7 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should return a record with invitation token and no errors to send invitation by email' do
-    invited_user = User.invite!(:email => "valid@email.com")
+    invited_user = User.invite!(email: 'valid@email.com')
     assert_empty invited_user.errors
     assert_predicate invited_user.invitation_token, :present?
     assert_equal 'valid@email.com', invited_user.email
@@ -322,7 +326,7 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should set all attributes with no errors' do
-    invited_user = User.invite!(:email => "valid@email.com", :username => 'first name')
+    invited_user = User.invite!(email: 'valid@email.com', username: 'first name')
     assert_empty invited_user.errors
     assert_equal 'first name', invited_user.username
     assert_predicate invited_user, :persisted?
@@ -331,7 +335,7 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should not validate other attributes when validate_on_invite is disabled' do
     validate_on_invite = User.validate_on_invite
     User.validate_on_invite = false
-    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    invited_user = User.invite!(email: 'valid@email.com', username: 'a' * 50)
     assert_empty invited_user.errors
     User.validate_on_invite = validate_on_invite
   end
@@ -339,7 +343,7 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should validate other attributes when validate_on_invite is enabled' do
     validate_on_invite = User.validate_on_invite
     User.validate_on_invite = true
-    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    invited_user = User.invite!(email: 'valid@email.com', username: 'a' * 50)
     refute_empty invited_user.errors[:username]
     User.validate_on_invite = validate_on_invite
   end
@@ -347,7 +351,7 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should not validate password when validate_on_invite is enabled' do
     validate_on_invite = User.validate_on_invite
     User.validate_on_invite = true
-    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    invited_user = User.invite!(email: 'valid@email.com', username: 'a' * 50)
     refute_empty invited_user.errors
     assert_empty invited_user.errors[:password]
     User.validate_on_invite = validate_on_invite
@@ -356,33 +360,33 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should validate other attributes when validate_on_invite is enabled and email is not present' do
     validate_on_invite = User.validate_on_invite
     User.validate_on_invite = true
-    invited_user = User.invite!(:email => "", :username => "a"*50)
+    invited_user = User.invite!(email: '', username: 'a' * 50)
     refute_empty invited_user.errors[:email]
     refute_empty invited_user.errors[:username]
     User.validate_on_invite = validate_on_invite
   end
 
   test 'should return a record with errors if user was found by e-mail' do
-    existing_user = User.new(:email => "valid@email.com")
-    existing_user.save(:validate => false)
-    user = User.invite!(:email => "valid@email.com")
+    existing_user = User.new(email: 'valid@email.com')
+    existing_user.save(validate: false)
+    user = User.invite!(email: 'valid@email.com')
     assert_equal user, existing_user
     assert_equal ['has already been taken'], user.errors[:email]
-    same_user = User.invite!("email" => "valid@email.com")
+    same_user = User.invite!(email: 'valid@email.com')
     assert_equal same_user, existing_user
     assert_equal ['has already been taken'], same_user.errors[:email]
   end
 
   test 'should return a record with errors if user with pending invitation was found by e-mail' do
-    existing_user = User.invite!(:email => "valid@email.com")
-    user = User.invite!(:email => "valid@email.com")
+    existing_user = User.invite!(email: 'valid@email.com')
+    user = User.invite!(email: 'valid@email.com')
     assert_equal user, existing_user
     assert_equal [], user.errors[:email]
     resend_invitation = User.resend_invitation
     begin
       User.resend_invitation = false
 
-      user = User.invite!(:email => "valid@email.com")
+      user = User.invite!(email: 'valid@email.com')
       assert_equal user, existing_user
       assert_equal ['has already been taken'], user.errors[:email]
     ensure
@@ -394,9 +398,9 @@ class InvitableTest < ActiveSupport::TestCase
     begin
       validate_on_invite = User.validate_on_invite
       User.validate_on_invite = true
-      existing_user = User.new(:email => "valid@email.com")
-      existing_user.save(:validate => false)
-      user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+      existing_user = User.new(email: 'valid@email.com')
+      existing_user.save(validate: false)
+      user = User.invite!(email: 'valid@email.com', username: 'a' * 50)
       assert_equal user, existing_user
       assert_equal ['has already been taken'], user.errors[:email]
       refute_empty user.errors[:username]
@@ -406,19 +410,19 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should return a new record with errors if e-mail is blank' do
-    invited_user = User.invite!(:email => '')
+    invited_user = User.invite!(email: '')
     assert invited_user.new_record?
     assert_equal ["can't be blank"], invited_user.errors[:email]
   end
 
   test 'should return a new record with errors if e-mail is invalid' do
-    invited_user = User.invite!(:email => 'invalid_email')
+    invited_user = User.invite!(email: 'invalid_email')
     assert invited_user.new_record?
-    assert_equal ["is invalid"], invited_user.errors[:email]
+    assert_equal ['is invalid'], invited_user.errors[:email]
   end
 
   test 'should set all attributes with errors if e-mail is invalid' do
-    invited_user = User.invite!(:email => "invalid_email.com", :username => 'first name')
+    invited_user = User.invite!(email: 'invalid_email.com', username: 'first name')
     assert invited_user.new_record?
     assert_equal 'first name', invited_user.username
     refute_empty invited_user.errors
@@ -427,34 +431,34 @@ class InvitableTest < ActiveSupport::TestCase
   test 'should find a user to set his password based on invitation_token' do
     user = new_user
     user.invite!
-    invited_user = User.accept_invitation!(:invitation_token => Thread.current[:token])
+    invited_user = User.accept_invitation!(invitation_token: Thread.current[:token])
     assert_equal invited_user, user
   end
 
   test 'should return a new record with errors if no invitation_token is found' do
-    invited_user = User.accept_invitation!(:invitation_token => 'invalid_token')
+    invited_user = User.accept_invitation!(invitation_token: 'invalid_token')
     assert invited_user.new_record?
     assert_equal ['is invalid'], invited_user.errors[:invitation_token]
   end
 
   test 'should return a new record with errors if invitation_token is blank' do
-    invited_user = User.accept_invitation!(:invitation_token => '')
+    invited_user = User.accept_invitation!(invitation_token: '')
     assert invited_user.new_record?
     assert_equal ["can't be blank"], invited_user.errors[:invitation_token]
   end
 
   test 'should return record with errors if invitation_token has expired' do
     User.stubs(:invite_for).returns(10.hours)
-    invited_user = User.invite!(:email => "valid@email.com")
+    invited_user = User.invite!(email: 'valid@email.com')
     invited_user.invitation_created_at = 2.days.ago
-    invited_user.save(:validate => false)
-    user = User.accept_invitation!(:invitation_token => Thread.current[:token])
+    invited_user.save(validate: false)
+    user = User.accept_invitation!(invitation_token: Thread.current[:token])
     assert_equal user, invited_user
-    assert_equal ["is invalid"], user.errors[:invitation_token]
+    assert_equal ['is invalid'], user.errors[:invitation_token]
   end
 
   test 'should allow record modification using block' do
-    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50) do |u|
+    invited_user = User.invite!(email: 'valid@email.com', username: 'a' * 50) do |u|
       u.password = '123123'
       u.password_confirmation = '123123'
     end
@@ -462,13 +466,13 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should set successfully user password given the new password and confirmation' do
-    user = new_user(:password => nil, :password_confirmation => nil)
+    user = new_user(password: nil, password_confirmation: nil)
     user.invite!
 
     User.accept_invitation!(
-      :invitation_token => Thread.current[:token],
-      :password => 'new_password',
-      :password_confirmation => 'new_password'
+      invitation_token: Thread.current[:token],
+      password: 'new_password',
+      password_confirmation: 'new_password',
     )
     user.reload
 
@@ -476,14 +480,14 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should return errors on other attributes even when password is valid' do
-    user = new_user(:password => nil, :password_confirmation => nil)
+    user = new_user(password: nil, password_confirmation: nil)
     user.invite!
 
     invited_user = User.accept_invitation!(
-      :invitation_token => Thread.current[:token],
-      :password => 'new_password',
-      :password_confirmation => 'new_password',
-      :username => 'a'*50
+      invitation_token: Thread.current[:token],
+      password: 'new_password',
+      password_confirmation: 'new_password',
+      username: 'a' * 50,
     )
     refute_empty invited_user.errors[:username]
 
@@ -492,14 +496,14 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'should check if created by invitation' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.created_by_invite?
 
     invited_user = User.accept_invitation!(
-      :invitation_token => Thread.current[:token],
-      :password => 'new_password',
-      :password_confirmation => 'new_password',
-      :username => 'a'
+      invitation_token: Thread.current[:token],
+      password: 'new_password',
+      password_confirmation: 'new_password',
+      username: 'a',
     )
     user.reload
     assert user.created_by_invite?
@@ -507,14 +511,14 @@ class InvitableTest < ActiveSupport::TestCase
 
 
   test 'should set other attributes on accepting invitation' do
-    user = new_user(:password => nil, :password_confirmation => nil)
+    user = new_user(password: nil, password_confirmation: nil)
     user.invite!
 
     invited_user = User.accept_invitation!(
-      :invitation_token => Thread.current[:token],
-      :password => 'new_password',
-      :password_confirmation => 'new_password',
-      :username => 'a'
+      invitation_token: Thread.current[:token],
+      password: 'new_password',
+      password_confirmation: 'new_password',
+      username: 'a',
     )
     assert invited_user.errors[:username].blank?
 
@@ -554,13 +558,13 @@ class InvitableTest < ActiveSupport::TestCase
 
   test 'should not send an invitation if we want to skip the invitation' do
     assert_no_difference('ActionMailer::Base.deliveries.size') do
-      User.invite!(:email => "valid@email.com", :username => "a"*50, :skip_invitation => true)
+      User.invite!(email: 'valid@email.com', username: 'a' * 50, skip_invitation: true)
     end
   end
 
   test 'should not send an invitation if we want to skip the invitation with block' do
     assert_no_difference('ActionMailer::Base.deliveries.size') do
-      User.invite!(:email => "valid@email.com", :username => "a"*50) do |u|
+      User.invite!(email: 'valid@email.com', username: 'a' * 50) do |u|
         u.skip_invitation = true
       end
     end
@@ -595,22 +599,22 @@ class InvitableTest < ActiveSupport::TestCase
 
   test 'user.invite! should set the invited_by attribute if passed' do
     user = new_user
-    inviting_user = User.new(:email => "valid@email.com")
-    inviting_user.save(:validate => false)
+    inviting_user = User.new(email: 'valid@email.com')
+    inviting_user.save(validate: false)
     user.invite!(inviting_user)
     assert_equal inviting_user, user.invited_by
     assert_equal inviting_user.class.to_s, user.invited_by_type
   end
 
   test 'user.accept_invitation! should trigger callbacks' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert_callbacks_not_fired :after_invitation_accepted, user
     user.accept_invitation!
     assert_callbacks_fired :after_invitation_accepted, user
   end
 
   test 'user.accept_invitation! should not trigger callbacks if validation fails' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert_callbacks_not_fired :after_invitation_accepted, user
     user.username='a'*50
     user.accept_invitation!
@@ -618,7 +622,7 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'user.accept_invitation! should confirm user if confirmable' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.accept_invitation!
 
     assert user.confirmed?
@@ -626,7 +630,7 @@ class InvitableTest < ActiveSupport::TestCase
   end
 
   test 'user.accept_invitation! should not confirm user if validation fails' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.username='a'*50
     user.accept_invitation!
     user.reload
@@ -640,7 +644,7 @@ class InvitableTest < ActiveSupport::TestCase
     begin
       User.send_password_change_notification = true
 
-      user = User.invite!(:email => "valid@email.com")
+      user = User.invite!(email: 'valid@email.com')
 
       assert_no_difference('ActionMailer::Base.deliveries.size') do
         user.password = user.password_confirmation = '123456789'
@@ -671,53 +675,53 @@ class InvitableTest < ActiveSupport::TestCase
 
   test "user.invite! should downcase the class's case_insensitive_keys" do
     # Devise default is :email
-    user = User.invite!(:email => "UPPERCASE@email.com")
-    assert user.email == "uppercase@email.com"
+    user = User.invite!(email: 'UPPERCASE@email.com')
+    assert user.email == 'uppercase@email.com'
   end
 
   test "user.invite! should strip whitespace from the class's strip_whitespace_keys" do
     # Devise default is email
-    user = User.invite!(:email => " valid@email.com ", :active => true)
-    assert user.email == "valid@email.com"
+    user = User.invite!(email: ' valid@email.com ', active: true)
+    assert user.email == 'valid@email.com'
     assert user.active == true
   end
 
   test "user.invite! should trigger callbacks" do
-    user = User.new(email: "valid@email.com")
+    user = User.new(email: 'valid@email.com')
     assert_callbacks_not_fired :after_invitation_created, user
     user.invite!
     assert_callbacks_fired :after_invitation_created, user
   end
 
   test 'should pass validation before accept if field is required in post-invited instance' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.testing_accepted_or_not_invited = true
     user.valid?
     assert_empty user.errors
   end
 
   test 'should fail validation after accept if field is required in post-invited instance' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.testing_accepted_or_not_invited = true
     assert_predicate user, :accept_invitation!
-    user = User.where(:email => "valid@email.com").first
+    user = User.where(email: 'valid@email.com').first
     user.valid?
     refute_empty user.errors
   end
 
   test 'should pass validation after accept if field is required in post-invited instance' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.username = 'test'
     user.testing_accepted_or_not_invited = true
     assert_predicate user, :accept_invitation!
-    user = User.where(:email => "valid@email.com").first
+    user = User.where(email: 'valid@email.com').first
     user.bio = "Test"
     user.valid?
     assert_empty user.errors
   end
 
   test 'should return instance with errors if invitation_token is nil' do
-    User.create(:email => 'admin@test.com', :password => '123456', :password_confirmation => '123456')
+    User.create(email: 'admin@test.com', password: '123456', password_confirmation: '123456')
     user = User.accept_invitation!
     refute_empty user.errors
   end
@@ -727,9 +731,9 @@ class InvitableTest < ActiveSupport::TestCase
     assert_equal 0, User.invitation_accepted.count
     assert_equal 0, User.created_by_invite.count
 
-    User.invite!(:email => "invalid@email.com")
-    User.invite!(:email => "another_invalid@email.com")
-    user = User.invite!(:email => "valid@email.com")
+    User.invite!(email: 'invalid@email.com')
+    User.invite!(email: 'another_invalid@email.com')
+    user = User.invite!(email: 'valid@email.com')
 
     assert_equal 3, User.invitation_not_accepted.count
     assert_equal 0, User.invitation_accepted.count
@@ -754,10 +758,22 @@ class InvitableTest < ActiveSupport::TestCase
         (?=.*[A-Z])        # Must contain an upper case character
         (?=.*[[:^alnum:]]) # Must contain a symbol
       /x
-    User.stubs(:invite_key).returns(:password => PASSWORD_FORMAT)
+    User.stubs(:invite_key).returns(password: PASSWORD_FORMAT)
     Devise.stubs(:friendly_token).returns('onlylowercaseletters')
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     assert user.persisted?
     assert user.errors.empty?
   end
+
+  test 'should set initial password following Devise.password_length' do
+    user = User.invite!(email: 'valid@email.com')
+    assert_empty user.errors
+    assert_equal Devise.password_length.last, user.password.length
+  end
+
+  test 'should set initial passsword using :validatable with custom password_length' do
+    user = Validatable.invite!(email: 'valid@email.com')
+    assert_empty user.errors
+    assert_equal Validatable.password_length.last, user.password.length
+  end
 end