devise 4.4.3 → 4.9.4

data/test/models/database_authenticatable_test.rb

@@ -1,283 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'test_models'
-require 'digest/sha1'
-
-class DatabaseAuthenticatableTest < ActiveSupport::TestCase
-  def setup
-    setup_mailer
-  end
-
-  test 'should downcase case insensitive keys when saving' do
-    # case_insensitive_keys is set to :email by default.
-    email = 'Foo@Bar.com'
-    user = new_user(email: email)
-
-    assert_equal email, user.email
-    user.save!
-    assert_equal email.downcase, user.email
-  end
-
-  test 'should downcase case insensitive keys that refer to virtual attributes when saving' do
-    email        = 'Foo@Bar1.com'
-    confirmation = 'Foo@Bar1.com'
-    attributes   = valid_attributes(email: email, email_confirmation: confirmation)
-    user = UserWithVirtualAttributes.new(attributes)
-
-    assert_equal confirmation, user.email_confirmation
-    user.save!
-    assert_equal confirmation.downcase, user.email_confirmation
-  end
-
-  test 'should not mutate value assigned to case insensitive key' do
-    email          = 'Foo@Bar.com'
-    original_email = email.dup
-    user           = new_user(email: email)
-
-    user.save!
-    assert_equal original_email, email
-  end
-
-  test 'should remove whitespace from strip whitespace keys when saving' do
-    # strip_whitespace_keys is set to :email by default.
-    email = ' foo@bar.com '
-    user = new_user(email: email)
-
-    assert_equal email, user.email
-    user.save!
-    assert_equal email.strip, user.email
-  end
-
-  test 'should not mutate value assigned to string whitespace key' do
-    email          = ' foo@bar.com '
-    original_email = email.dup
-    user           = new_user(email: email)
-
-    user.save!
-    assert_equal original_email, email
-  end
-
-  test "doesn't throw exception when globally configured strip_whitespace_keys are not present on a model" do
-    swap Devise, strip_whitespace_keys: [:fake_key] do
-      assert_nothing_raised { create_user }
-    end
-  end
-
-  test "doesn't throw exception when globally configured case_insensitive_keys are not present on a model" do
-    swap Devise, case_insensitive_keys: [:fake_key] do
-      assert_nothing_raised { create_user }
-    end
-  end
-
-  test "param filter should not convert booleans and integer to strings" do
-    conditions = { "login" => "foo@bar.com", "bool1" => true, "bool2" => false, "fixnum" => 123, "will_be_converted" => (1..10) }
-    conditions = Devise::ParameterFilter.new([], []).filter(conditions)
-    assert_equal( { "login" => "foo@bar.com", "bool1" => "true", "bool2" => "false", "fixnum" => "123", "will_be_converted" => "1..10" }, conditions)
-  end
-
-  test 'param filter should filter case_insensitive_keys as insensitive' do
-    conditions = {'insensitive' => 'insensitive_VAL', 'sensitive' => 'sensitive_VAL'}
-    conditions = Devise::ParameterFilter.new(['insensitive'], []).filter(conditions)
-    assert_equal( {'insensitive' => 'insensitive_val', 'sensitive' => 'sensitive_VAL'}, conditions )
-  end
-
-  test 'param filter should filter strip_whitespace_keys stripping whitespaces' do
-    conditions = {'strip_whitespace' => ' strip_whitespace_val ', 'do_not_strip_whitespace' => ' do_not_strip_whitespace_val '}
-    conditions = Devise::ParameterFilter.new([], ['strip_whitespace']).filter(conditions)
-    assert_equal( {'strip_whitespace' => 'strip_whitespace_val', 'do_not_strip_whitespace' => ' do_not_strip_whitespace_val '}, conditions )
-  end
-
-  test 'should respond to password and password confirmation' do
-    user = new_user
-    assert user.respond_to?(:password)
-    assert user.respond_to?(:password_confirmation)
-  end
-
-  test 'should generate a hashed password while setting password' do
-    user = new_user
-    assert_present user.encrypted_password
-  end
-
-  test 'should support custom hashing methods' do
-    user = UserWithCustomHashing.new(password: '654321')
-    assert_equal user.encrypted_password, '123456'
-  end
-
-  test 'allow authenticatable_salt to work even with nil hashed password' do
-    user = User.new
-    user.encrypted_password = nil
-    assert_nil user.authenticatable_salt
-  end
-
-  test 'should not generate a hashed password if password is blank' do
-    assert_blank new_user(password: nil).encrypted_password
-    assert_blank new_user(password: '').encrypted_password
-  end
-
-  test 'should hash password again if password has changed' do
-    user = create_user
-    encrypted_password = user.encrypted_password
-    user.password = user.password_confirmation = 'new_password'
-    user.save!
-    assert_not_equal encrypted_password, user.encrypted_password
-  end
-
-  test 'should test for a valid password' do
-    user = create_user
-    assert user.valid_password?('12345678')
-    refute user.valid_password?('654321')
-  end
-
-  test 'should not raise error with an empty password' do
-    user = create_user
-    user.encrypted_password = ''
-    assert_nothing_raised { user.valid_password?('12345678') }
-  end
-
-  test 'should be an invalid password if the user has an empty password' do
-    user = create_user
-    user.encrypted_password = ''
-    refute user.valid_password?('654321')
-  end
-
-  test 'should respond to current password' do
-    assert new_user.respond_to?(:current_password)
-  end
-
-  test 'should update password with valid current password' do
-    user = create_user
-    assert user.update_with_password(current_password: '12345678',
-      password: 'pass4321', password_confirmation: 'pass4321')
-    assert user.reload.valid_password?('pass4321')
-  end
-
-  test 'should add an error to current password when it is invalid' do
-    user = create_user
-    refute user.update_with_password(current_password: 'other',
-      password: 'pass4321', password_confirmation: 'pass4321')
-    assert user.reload.valid_password?('12345678')
-    assert_match "is invalid", user.errors[:current_password].join
-  end
-
-  test 'should add an error to current password when it is blank' do
-    user = create_user
-    refute user.update_with_password(password: 'pass4321',
-      password_confirmation: 'pass4321')
-    assert user.reload.valid_password?('12345678')
-    assert_match "can't be blank", user.errors[:current_password].join
-  end
-
-  test 'should run validations even when current password is invalid or blank' do
-    user = UserWithValidation.create!(valid_attributes)
-    user.save
-    assert user.persisted?
-    refute user.update_with_password(username: "")
-    assert_match "usertest", user.reload.username
-    assert_match "can't be blank", user.errors[:username].join
-  end
-
-  test 'should ignore password and its confirmation if they are blank' do
-    user = create_user
-    assert user.update_with_password(current_password: '12345678', email: "new@example.com")
-    assert_equal "new@example.com", user.email
-  end
-
-  test 'should not update password with invalid confirmation' do
-    user = create_user
-    refute user.update_with_password(current_password: '12345678',
-      password: 'pass4321', password_confirmation: 'other')
-    assert user.reload.valid_password?('12345678')
-  end
-
-  test 'should clean up password fields on failure' do
-    user = create_user
-    refute user.update_with_password(current_password: '12345678',
-      password: 'pass4321', password_confirmation: 'other')
-    assert user.password.blank?
-    assert user.password_confirmation.blank?
-  end
-
-  test 'should update the user without password' do
-    user = create_user
-    user.update_without_password(email: 'new@example.com')
-    assert_equal 'new@example.com', user.email
-  end
-
-  test 'should not update password without password' do
-    user = create_user
-    user.update_without_password(password: 'pass4321', password_confirmation: 'pass4321')
-    assert !user.reload.valid_password?('pass4321')
-    assert user.valid_password?('12345678')
-  end
-
-  test 'should destroy user if current password is valid' do
-    user = create_user
-    assert user.destroy_with_password('12345678')
-    assert !user.persisted?
-  end
-
-  test 'should not destroy user with invalid password' do
-    user = create_user
-    refute user.destroy_with_password('other')
-    assert user.persisted?
-    assert_match "is invalid", user.errors[:current_password].join
-  end
-
-  test 'should not destroy user with blank password' do
-    user = create_user
-    refute user.destroy_with_password(nil)
-    assert user.persisted?
-    assert_match "can't be blank", user.errors[:current_password].join
-  end
-
-  test 'should not email on password change' do
-    user = create_user
-    assert_email_not_sent do
-      assert user.update_attributes(password: 'newpass', password_confirmation: 'newpass')
-    end
-  end
-
-  test 'should notify previous email on email change when configured' do
-    swap Devise, send_email_changed_notification: true do
-      user = create_user
-      original_email = user.email
-      assert_email_sent original_email do
-        assert user.update_attributes(email: 'new-email@example.com')
-      end
-      assert_match original_email, ActionMailer::Base.deliveries.last.body.encoded
-    end
-  end
-
-  test 'should notify email on password change when configured' do
-    swap Devise, send_password_change_notification: true do
-      user = create_user
-      assert_email_sent user.email do
-        assert user.update_attributes(password: 'newpass', password_confirmation: 'newpass')
-      end
-      assert_match user.email, ActionMailer::Base.deliveries.last.body.encoded
-    end
-  end
-
-  test 'downcase_keys with validation' do
-    User.create(email: "HEllO@example.com", password: "123456")
-    user = User.create(email: "HEllO@example.com", password: "123456")
-    assert !user.valid?
-  end
-
-  test 'required_fields should be encryptable_password and the email field by default' do
-    assert_equal Devise::Models::DatabaseAuthenticatable.required_fields(User), [
-      :encrypted_password,
-      :email
-    ]
-  end
-
-  test 'required_fields should be encryptable_password and the login when the login is on authentication_keys' do
-    swap Devise, authentication_keys: [:login] do
-      assert_equal Devise::Models::DatabaseAuthenticatable.required_fields(User), [
-        :encrypted_password,
-        :login
-      ]
-    end
-  end
-end

data/test/models/lockable_test.rb

@@ -1,352 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class LockableTest < ActiveSupport::TestCase
-  def setup
-    setup_mailer
-  end
-
-  test "should respect maximum attempts configuration" do
-    user = create_user
-    user.confirm
-    swap Devise, maximum_attempts: 2 do
-      2.times { user.valid_for_authentication?{ false } }
-      assert user.reload.access_locked?
-    end
-  end
-
-  test "should increment failed_attempts on successful validation if the user is already locked" do
-    user = create_user
-    user.confirm
-
-    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 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
-      3.times { user.valid_for_authentication?{ false } }
-      assert !user.access_locked?
-      assert_equal 0, user.failed_attempts
-    end
-  end
-
-  test 'should be valid for authentication with a unlocked user' do
-    user = create_user
-    user.lock_access!
-    user.unlock_access!
-    assert user.valid_for_authentication?{ true }
-  end
-
-  test "should verify whether a user is locked or not" do
-    user = create_user
-    refute user.access_locked?
-    user.lock_access!
-    assert user.access_locked?
-  end
-
-  test "active_for_authentication? should be the opposite of locked?" do
-    user = create_user
-    user.confirm
-    assert user.active_for_authentication?
-    user.lock_access!
-    refute user.active_for_authentication?
-  end
-
-  test "should unlock a user by cleaning locked_at, failed_attempts and unlock_token" do
-    user = create_user
-    user.lock_access!
-    assert_not_nil user.reload.locked_at
-    assert_not_nil user.reload.unlock_token
-
-    user.unlock_access!
-    assert_nil user.reload.locked_at
-    assert_nil user.reload.unlock_token
-    assert_equal 0, user.reload.failed_attempts
-  end
-
-  test "new user should not be locked and should have zero failed_attempts" do
-    refute new_user.access_locked?
-    assert_equal 0, create_user.failed_attempts
-  end
-
-  test "should unlock user after unlock_in period" do
-    swap Devise, unlock_in: 3.hours do
-      user = new_user
-      user.locked_at = 2.hours.ago
-      assert user.access_locked?
-
-      Devise.unlock_in = 1.hour
-      refute user.access_locked?
-    end
-  end
-
-  test "should not unlock in 'unlock_in' if :time unlock strategy is not set" do
-    swap Devise, unlock_strategy: :email do
-      user = new_user
-      user.locked_at = 2.hours.ago
-      assert user.access_locked?
-    end
-  end
-
-  test "should set unlock_token when locking" do
-    user = create_user
-    assert_nil user.unlock_token
-    user.lock_access!
-    assert_not_nil user.unlock_token
-  end
-
-  test "should never generate the same unlock token for different users" do
-    unlock_tokens = []
-    3.times do
-      user = create_user
-      user.lock_access!
-      token = user.unlock_token
-      assert !unlock_tokens.include?(token)
-      unlock_tokens << token
-    end
-  end
-
-  test "should not generate unlock_token when :email is not an unlock strategy" do
-    swap Devise, unlock_strategy: :time do
-      user = create_user
-      user.lock_access!
-      assert_nil user.unlock_token
-    end
-  end
-
-  test "should send email with unlock instructions when :email is an unlock strategy" do
-    swap Devise, unlock_strategy: :email do
-      user = create_user
-      assert_email_sent do
-        user.lock_access!
-      end
-    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
-      user = create_user
-      assert_email_not_sent do
-        user.lock_access!
-      end
-    end
-  end
-
-  test 'should find and unlock a user automatically based on raw token' do
-    user = create_user
-    raw  = user.send_unlock_instructions
-    locked_user = User.unlock_access_by_token(raw)
-    assert_equal locked_user, user
-    refute user.reload.access_locked?
-  end
-
-  test 'should return a new record with errors when a invalid token is given' do
-    locked_user = User.unlock_access_by_token('invalid_token')
-    refute locked_user.persisted?
-    assert_equal "is invalid", locked_user.errors[:unlock_token].join
-  end
-
-  test 'should return a new record with errors when a blank token is given' do
-    locked_user = User.unlock_access_by_token('')
-    refute locked_user.persisted?
-    assert_equal "can't be blank", locked_user.errors[:unlock_token].join
-  end
-
-  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)
-    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")
-    refute 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")
-    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
-      user = create_user
-      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
-      user = create_user
-      unlock_user = User.send_unlock_instructions(email: user.email)
-      refute unlock_user.persisted?
-      assert_equal "can't be blank", unlock_user.errors[:username].join
-    end
-  end
-
-  test 'should not be able to send instructions if the user is not locked' do
-    user = create_user
-    refute user.resend_unlock_instructions
-    refute user.access_locked?
-    assert_equal 'was not locked', user.errors[:email].join
-  end
-
-  test 'should not be able to send instructions if the user if not locked and have username as unlock key' do
-    swap Devise, unlock_keys: [:username] do
-      user = create_user
-      refute user.resend_unlock_instructions
-      refute user.access_locked?
-      assert_equal 'was not locked', user.errors[:username].join
-    end
-  end
-
-  test 'should unlock account if lock has expired and increase attempts on failure' do
-    swap Devise, unlock_in: 1.minute do
-      user = create_user
-      user.confirm
-
-      user.failed_attempts = 2
-      user.locked_at = 2.minutes.ago
-
-      user.valid_for_authentication? { false }
-      assert_equal 1, user.failed_attempts
-    end
-  end
-
-  test 'should unlock account if lock has expired on success' do
-    swap Devise, unlock_in: 1.minute do
-      user = create_user
-      user.confirm
-
-      user.failed_attempts = 2
-      user.locked_at = 2.minutes.ago
-
-      user.valid_for_authentication? { true }
-      assert_equal 0, user.failed_attempts
-      assert_nil user.locked_at
-    end
-  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
-        assert_equal Devise::Models::Lockable.required_fields(User), [
-         :failed_attempts,
-         :locked_at,
-         :unlock_token
-        ]
-      end
-    end
-  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
-        assert_equal Devise::Models::Lockable.required_fields(User), [
-         :failed_attempts,
-         :locked_at
-        ]
-      end
-    end
-  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
-        assert_equal Devise::Models::Lockable.required_fields(User), [
-         :failed_attempts,
-         :unlock_token
-        ]
-      end
-    end
-  end
-
-  test 'should not return a locked unauthenticated message if in paranoid mode' do
-    swap Devise, paranoid: :true do
-      user = create_user
-      user.failed_attempts = Devise.maximum_attempts + 1
-      user.lock_access!
-
-      assert_equal :invalid, user.unauthenticated_message
-    end
-  end
-
-  test 'should return last attempt message if user made next-to-last attempt of password entering' do
-    swap Devise, last_attempt_warning: true, lock_strategy: :failed_attempts do
-      user = create_user
-      user.failed_attempts = Devise.maximum_attempts - 2
-      assert_equal :invalid, user.unauthenticated_message
-
-      user.failed_attempts = Devise.maximum_attempts - 1
-      assert_equal :last_attempt, user.unauthenticated_message
-
-      user.failed_attempts = Devise.maximum_attempts
-      assert_equal :locked, user.unauthenticated_message
-    end
-  end
-
-  test 'should not return last attempt message if last_attempt_warning is disabled' do
-    swap Devise, last_attempt_warning: false, lock_strategy: :failed_attempts do
-      user = create_user
-      user.failed_attempts = Devise.maximum_attempts - 1
-      assert_equal :invalid, user.unauthenticated_message
-    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
-
-  test 'unlock_strategy_enabled? should return true for both, email, and time strategies if :both is used' do
-    swap Devise, unlock_strategy: :both do
-      user = create_user
-      assert_equal true, user.unlock_strategy_enabled?(:both)
-      assert_equal true, user.unlock_strategy_enabled?(:time)
-      assert_equal true, user.unlock_strategy_enabled?(:email)
-      assert_equal false, user.unlock_strategy_enabled?(:none)
-      assert_equal false, user.unlock_strategy_enabled?(:an_undefined_strategy)
-    end
-  end
-
-  test 'unlock_strategy_enabled? should return true only for the configured strategy' do
-    swap Devise, unlock_strategy: :email do
-      user = create_user
-      assert_equal false, user.unlock_strategy_enabled?(:both)
-      assert_equal false, user.unlock_strategy_enabled?(:time)
-      assert_equal true, user.unlock_strategy_enabled?(:email)
-      assert_equal false, user.unlock_strategy_enabled?(:none)
-      assert_equal false, user.unlock_strategy_enabled?(:an_undefined_strategy)
-    end
-  end
-end

data/test/models/omniauthable_test.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class OmniauthableTest < ActiveSupport::TestCase
-  test 'required_fields should contain the fields that Devise uses' do
-    assert_equal Devise::Models::Omniauthable.required_fields(User), []
-  end
-end