devise_invitable 1.7.5 → 2.0.0

data/test/integration/invitation_remove_test.rb

@@ -4,26 +4,26 @@ require 'integration_tests_helper'
 class InvitationRemoveTest < ActionDispatch::IntegrationTest
 
   test 'invited user can choose to remove his account/invite' do
-    User.invite!(:email => "valid@email.com")
+    User.invite!(email: 'valid@email.com')
 
     # remove!
-    visit remove_user_invitation_path(:invitation_token => Thread.current[:token])
+    visit remove_user_invitation_path(invitation_token: Thread.current[:token])
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'Your invitation was removed.')
+    assert page.has_css?('p#notice', text: 'Your invitation was removed.')
     
     # try to remove again!
-    visit remove_user_invitation_path(:invitation_token => Thread.current[:token])
+    visit remove_user_invitation_path(invitation_token: Thread.current[:token])
     assert_equal root_path, current_path
-    assert page.has_css?('p#alert', :text => 'The invitation token provided is not valid!')
+    assert page.has_css?('p#alert', text: 'The invitation token provided is not valid!')
   end
 
   test 'accepted user cannot remove his account (by using the original invitation token)' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     saved_token = Thread.current[:token]
     user.accept_invitation!
     
-    visit remove_user_invitation_path(:invitation_token =>  saved_token)
+    visit remove_user_invitation_path(invitation_token: saved_token)
     assert_equal root_path, current_path
-    assert page.has_css?('p#alert', :text => 'The invitation token provided is not valid!')
+    assert page.has_css?('p#alert', text: 'The invitation token provided is not valid!')
   end
 end

data/test/integration/invitation_test.rb

@@ -9,18 +9,18 @@ class InvitationTest < ActionDispatch::IntegrationTest
   def send_invitation(url = new_user_invitation_path, &block)
     visit url
 
-    fill_in 'user_email', :with => 'user@test.com'
+    fill_in 'user_email', with: 'user@test.com'
     yield if block_given?
     click_button 'Send an invitation'
   end
 
-  def set_password(options={}, &block)
+  def set_password(options = {}, &block)
     unless options[:visit] == false
-      visit accept_user_invitation_path(:invitation_token => options[:invitation_token])
+      visit accept_user_invitation_path(invitation_token: options[:invitation_token])
     end
 
-    fill_in 'user_password', :with => '987654321'
-    fill_in 'user_password_confirmation', :with => '987654321'
+    fill_in 'user_password', with: '987654321'
+    fill_in 'user_password_confirmation', with: '987654321'
     yield if block_given?
     click_button options[:button] || 'Set my password'
   end
@@ -28,7 +28,7 @@ class InvitationTest < ActionDispatch::IntegrationTest
   test 'not authenticated user should be able to send a free invitation' do
     send_invitation new_free_invitation_path
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
   end
 
   test 'not authenticated user should not be able to send an invitation' do
@@ -41,19 +41,19 @@ class InvitationTest < ActionDispatch::IntegrationTest
 
     send_invitation
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
   end
 
   test 'authenticated user with existing email should receive an error message' do
     user = create_full_user
     sign_in_as_user(user)
     send_invitation do
-      fill_in 'user_email', :with => user.email
+      fill_in 'user_email', with: user.email
     end
 
     assert_equal user_invitation_path, current_path
     assert page.has_css?("input[type=text][value='#{user.email}']")
-    assert page.has_css?('#error_explanation li', :text => 'Email has already been taken')
+    assert page.has_css?('#error_explanation li', text: 'Email has already been taken')
   end
 
   test 'authenticated user should not be able to visit edit invitation page' do
@@ -65,63 +65,63 @@ class InvitationTest < ActionDispatch::IntegrationTest
   end
 
   test 'invited user without password should not be able to sign in' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.password = 'test'
     sign_in_as_user user
 
     assert_equal new_user_session_path, current_path
-    assert page.has_css?('p#alert', :text => 'You have a pending invitation, accept it to finish creating your account.')
+    assert page.has_css?('p#alert', text: 'You have a pending invitation, accept it to finish creating your account.')
   end
 
   test 'invited user with password should not be able to sign in' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.password = '987654321'
     user.save
     sign_in_as_user user
 
     assert_equal new_user_session_path, current_path
-    assert page.has_css?('p#alert', :text => 'You have a pending invitation, accept it to finish creating your account.')
+    assert page.has_css?('p#alert', text: 'You have a pending invitation, accept it to finish creating your account.')
   end
 
   test 'not authenticated user with invalid invitation token should not be able to set his password' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
     user.accept_invitation!
-    visit accept_user_invitation_path(:invitation_token => 'invalid_token')
+    visit accept_user_invitation_path(invitation_token: 'invalid_token')
 
     assert_equal root_path, current_path
-    assert page.has_css?('p#alert', :text => 'The invitation token provided is not valid!')
+    assert page.has_css?('p#alert', text: 'The invitation token provided is not valid!')
   end
 
   test 'not authenticated user with valid invitation token but invalid password should not be able to set his password' do
-    user = User.invite!(:email => "valid@email.com")
-    set_password :invitation_token => Thread.current[:token] do
-      fill_in 'Password confirmation', :with => 'other_password'
+    user = User.invite!(email: 'valid@email.com')
+    set_password invitation_token: Thread.current[:token] do
+      fill_in 'Password confirmation', with: 'other_password'
     end
     assert_equal user_invitation_path, current_path
-    assert page.has_css?('#error_explanation li', :text => /Password .*doesn\'t match/)
+    assert page.has_css?('#error_explanation li', text: /Password .*doesn\'t match/)
     assert !user.confirmed?
   end
 
   test 'not authenticated user with valid data should be able to change his password' do
-    user = User.invite!(:email => "valid@email.com")
-    set_password :invitation_token => Thread.current[:token]
+    user = User.invite!(email: 'valid@email.com')
+    set_password invitation_token: Thread.current[:token]
 
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'Your password was set successfully. You are now signed in.')
+    assert page.has_css?('p#notice', text: 'Your password was set successfully. You are now signed in.')
     assert user.reload.valid_password?('987654321')
     assert user.confirmed?
   end
 
   test 'after entering invalid data user should still be able to set his password' do
-    user = User.invite!(:email => "valid@email.com")
-    set_password :invitation_token => Thread.current[:token] do
-      fill_in 'Password confirmation', :with => 'other_password'
+    user = User.invite!(email: 'valid@email.com')
+    set_password invitation_token: Thread.current[:token] do
+      fill_in 'Password confirmation', with: 'other_password'
     end
     assert_equal user_invitation_path, current_path
     assert page.has_css?('#error_explanation')
 
-    set_password :visit => false
-    assert page.has_css?('p#notice', :text => 'Your password was set successfully. You are now signed in.')
+    set_password visit: false
+    assert page.has_css?('p#notice', text: 'Your password was set successfully. You are now signed in.')
     assert user.reload.valid_password?('987654321')
   end
 
@@ -129,8 +129,8 @@ class InvitationTest < ActionDispatch::IntegrationTest
     original_option_value = Devise.allow_insecure_sign_in_after_accept
     Devise.allow_insecure_sign_in_after_accept = true
 
-    User.invite!(:email => "valid@email.com")
-    set_password :invitation_token => Thread.current[:token]
+    User.invite!(email: 'valid@email.com')
+    set_password invitation_token: Thread.current[:token]
 
     assert_equal root_path, current_path
     Devise.allow_insecure_sign_in_after_accept = original_option_value
@@ -140,22 +140,22 @@ class InvitationTest < ActionDispatch::IntegrationTest
     original_option_value = Devise.allow_insecure_sign_in_after_accept
     Devise.allow_insecure_sign_in_after_accept = false
 
-    User.invite!(:email => "valid@email.com")
-    set_password :invitation_token => Thread.current[:token]
+    User.invite!(email: 'valid@email.com')
+    set_password invitation_token: Thread.current[:token]
 
     assert_equal new_user_session_path, current_path
     Devise.allow_insecure_sign_in_after_accept = original_option_value
   end
 
   test 'clear token and set invitation_accepted_at after recover password instead of accept_invitation' do
-    user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(email: 'valid@email.com')
 
     visit new_user_password_path
-    fill_in 'user_email', :with => 'valid@email.com'
+    fill_in 'user_email', with: 'valid@email.com'
     click_button 'Send me reset password instructions'
 
-    visit edit_user_password_path(:reset_password_token => Thread.current[:token])
-    set_password :visit => false, :button => 'Change my password'
+    visit edit_user_password_path(reset_password_token: Thread.current[:token])
+    set_password visit: false, button: 'Change my password'
 
     user.reload
     assert_nil user.invitation_token
@@ -174,7 +174,7 @@ class InvitationTest < ActionDispatch::IntegrationTest
       send_invitation
     end
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
     user = User.find(user.id)
     assert !user.has_invitations_left?
   end
@@ -191,7 +191,7 @@ class InvitationTest < ActionDispatch::IntegrationTest
       send_invitation
     end
     assert_equal user_invitation_path, current_path
-    assert page.has_css?('p#alert', :text => 'No invitations remaining')
+    assert page.has_css?('p#alert', text: 'No invitations remaining')
   end
 
   test 'user with nil invitation_limit should default to User.invitation_limit' do
@@ -204,7 +204,7 @@ class InvitationTest < ActionDispatch::IntegrationTest
 
     send_invitation
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
     user = User.find(user.id)
     assert_equal 2, user.invitation_limit
   end
@@ -219,13 +219,13 @@ class InvitationTest < ActionDispatch::IntegrationTest
 
     send_invitation
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
     user = User.find(user.id)
     assert_equal 2, user.invitation_limit
 
     send_invitation
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
     user = User.find(user.id)
     assert_equal 2, user.invitation_limit
   end
@@ -235,7 +235,7 @@ class InvitationTest < ActionDispatch::IntegrationTest
     sign_in_as_user(user)
     send_invitation
 
-    invited_user = User.where(:email => 'user@test.com').first
+    invited_user = User.where(email: 'user@test.com').first
     assert invited_user
     assert_equal user, invited_user.invited_by
   end
@@ -248,20 +248,20 @@ class InvitationTest < ActionDispatch::IntegrationTest
   end
 
   test 'authenticated admin should be able to send an admin invitation' do
-    admin = Admin.create(:email => 'admin@test.com', :password => '123456', :password_confirmation => '123456')
+    admin = Admin.create(email: 'admin@test.com', password: '123456', password_confirmation: '123456')
     sign_in_as_user admin
 
     send_invitation new_admin_path
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
   end
 
   test 'authenticated admin should be redirected to own page after send a free invitation' do
-    admin = Admin.create(:email => 'admin@test.com', :password => '123456', :password_confirmation => '123456')
+    admin = Admin.create(email: 'admin@test.com', password: '123456', password_confirmation: '123456')
     sign_in_as_user admin
 
     send_invitation new_free_invitation_path
     assert_equal root_path, current_path
-    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+    assert page.has_css?('p#notice', text: 'An invitation email has been sent to user@test.com.')
   end
 end

data/test/integration_tests_helper.rb

@@ -7,11 +7,11 @@ class ActionDispatch::IntegrationTest
   def create_full_user
     @user ||= begin
       user = User.create!(
-        :username              => 'usertest',
-        :email                 => 'fulluser@test.com',
-        :password              => '123456',
-        :password_confirmation => '123456',
-        :created_at            => Time.now.utc
+        username: 'usertest',
+        email: 'fulluser@test.com',
+        password: '123456',
+        password_confirmation: '123456',
+        created_at: Time.now.utc,
       )
       user.confirm
       user
@@ -22,8 +22,8 @@ class ActionDispatch::IntegrationTest
     user ||= create_full_user
     resource_name = user.class.name.underscore
     visit send("new_#{resource_name}_session_path")
-    fill_in "#{resource_name}_email", :with => user.email
-    fill_in "#{resource_name}_password", :with => user.password
+    fill_in "#{resource_name}_email", with: user.email
+    fill_in "#{resource_name}_password", with: user.password
     click_button 'Log in'
   end
 
@@ -35,7 +35,7 @@ class ActionDispatch::IntegrationTest
            "Expected status to be 301 or 302, got #{@integration_session.status}"
 
     url = prepend_host(url)
-    location = prepend_host(@integration_session.headers["Location"])
+    location = prepend_host(@integration_session.headers['Location'])
     assert_equal url, location
   end
 

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

@@ -15,7 +15,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 +74,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 +85,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 +125,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 +134,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 +158,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 +183,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 +238,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 +250,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 +261,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 +269,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 +284,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 +299,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 +314,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 +322,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 +331,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 +339,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 +347,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 +356,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 +394,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 +406,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 +427,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 +462,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 +476,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 +492,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 +507,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 +554,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 +595,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 +618,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 +626,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 +640,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 +671,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 +727,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,9 +754,9 @@ 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