devise 3.2.1 → 4.4.3

data/test/models/serializable_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class SerializableTest < ActiveSupport::TestCase
@@ -11,13 +13,13 @@ class SerializableTest < ActiveSupport::TestCase
   end
 
   test 'should not include unsafe keys on XML even if a new except is provided' do
-    assert_no_match(/email/, @user.to_xml(:except => :email))
-    assert_no_match(/confirmation-token/, @user.to_xml(:except => :email))
+    assert_no_match(/email/, @user.to_xml(except: :email))
+    assert_no_match(/confirmation-token/, @user.to_xml(except: :email))
   end
 
   test 'should include unsafe keys on XML if a force_except is provided' do
-    assert_no_match(/<email/, @user.to_xml(:force_except => :email))
-    assert_match(/confirmation-token/, @user.to_xml(:force_except => :email))
+    assert_no_match(/<email/, @user.to_xml(force_except: :email))
+    assert_match(/confirmation-token/, @user.to_xml(force_except: :email))
   end
 
   test 'should not include unsafe keys on JSON' do
@@ -26,13 +28,22 @@ class SerializableTest < ActiveSupport::TestCase
   end
 
   test 'should not include unsafe keys on JSON even if a new except is provided' do
-    assert_no_key "email", from_json(:except => :email)
-    assert_no_key "confirmation_token", from_json(:except => :email)
+    assert_no_key "email", from_json(except: :email)
+    assert_no_key "confirmation_token", from_json(except: :email)
   end
 
   test 'should include unsafe keys on JSON if a force_except is provided' do
-    assert_no_key "email", from_json(:force_except => :email)
-    assert_key "confirmation_token", from_json(:force_except => :email)
+    assert_no_key "email", from_json(force_except: :email)
+    assert_key "confirmation_token", from_json(force_except: :email)
+  end
+
+  test 'should not include unsafe keys in inspect' do
+    assert_match(/email/, @user.inspect)
+    assert_no_match(/confirmation_token/, @user.inspect)
+  end
+
+  test 'should accept frozen options' do
+    assert_key "username", @user.as_json({only: :username}.freeze)["user"]
   end
 
   def assert_key(key, subject)

data/test/models/timeoutable_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class TimeoutableTest < ActiveSupport::TestCase
@@ -7,11 +9,11 @@ class TimeoutableTest < ActiveSupport::TestCase
   end
 
   test 'should not be expired' do
-    assert_not new_user.timedout?(29.minutes.ago)
+    refute new_user.timedout?(29.minutes.ago)
   end
 
   test 'should not be expired when params is nil' do
-    assert_not new_user.timedout?(nil)
+    refute new_user.timedout?(nil)
   end
 
   test 'should use timeout_in method' do
@@ -19,29 +21,29 @@ class TimeoutableTest < ActiveSupport::TestCase
     user.instance_eval { def timeout_in; 10.minutes end }
 
     assert user.timedout?(12.minutes.ago)
-    assert_not user.timedout?(8.minutes.ago)
+    refute user.timedout?(8.minutes.ago)
   end
 
   test 'should not be expired when timeout_in method returns nil' do
     user = new_user
     user.instance_eval { def timeout_in; nil end }
-    assert_not user.timedout?(10.hours.ago)
+    refute user.timedout?(10.hours.ago)
   end
 
   test 'fallback to Devise config option' do
-    swap Devise, :timeout_in => 1.minute do
+    swap Devise, timeout_in: 1.minute do
       user = new_user
       assert user.timedout?(2.minutes.ago)
-      assert_not user.timedout?(30.seconds.ago)
+      refute user.timedout?(30.seconds.ago)
 
       Devise.timeout_in = 5.minutes
-      assert_not user.timedout?(2.minutes.ago)
+      refute user.timedout?(2.minutes.ago)
       assert user.timedout?(6.minutes.ago)
     end
   end
 
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Timeoutable.required_fields(User), []
+    assert_equal Devise::Models::Timeoutable.required_fields(User), []
   end
 
   test 'should not raise error if remember_created_at is not empty and rememberable is disabled' do

data/test/models/trackable_test.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class TrackableTest < ActiveSupport::TestCase
   test 'required_fields should contain the fields that Devise uses' do
-    assert_same_content Devise::Models::Trackable.required_fields(User), [
+    assert_equal Devise::Models::Trackable.required_fields(User), [
       :current_sign_in_at,
       :current_sign_in_ip,
       :last_sign_in_at,
@@ -10,4 +12,51 @@ class TrackableTest < ActiveSupport::TestCase
       :sign_in_count
     ]
   end
+
+  test 'update_tracked_fields should only set attributes but not save the record' do
+    user = create_user
+    request = mock
+    request.stubs(:remote_ip).returns("127.0.0.1")
+
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+    assert_equal 0, user.sign_in_count
+
+    user.update_tracked_fields(request)
+
+    assert_equal "127.0.0.1", user.current_sign_in_ip
+    assert_equal "127.0.0.1", user.last_sign_in_ip
+    assert_not_nil user.current_sign_in_at
+    assert_not_nil user.last_sign_in_at
+    assert_equal 1, user.sign_in_count
+
+    user.reload
+
+    assert_nil user.current_sign_in_ip
+    assert_nil user.last_sign_in_ip
+    assert_nil user.current_sign_in_at
+    assert_nil user.last_sign_in_at
+    assert_equal 0, user.sign_in_count
+  end
+
+  test "update_tracked_fields! should not persist invalid records" do
+    user = UserWithValidations.new
+    request = mock
+    request.stubs(:remote_ip).returns("127.0.0.1")
+
+    assert_not user.update_tracked_fields!(request)
+    assert_not user.persisted?
+  end
+
+  test "update_tracked_fields! should not run model validations" do
+    user = User.new
+    request = mock
+    request.stubs(:remote_ip).returns("127.0.0.1")
+
+    user.expects(:after_validation_callback).never
+
+    assert_not user.update_tracked_fields!(request)
+  end
 end

data/test/models/validatable_test.rb

@@ -1,9 +1,11 @@
 # encoding: UTF-8
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class ValidatableTest < ActiveSupport::TestCase
   test 'should require email to be set' do
-    user = new_user(:email => nil)
+    user = new_user(email: nil)
     assert user.invalid?
     assert user.errors[:email]
     assert_equal 'can\'t be blank', user.errors[:email].join
@@ -12,7 +14,7 @@ class ValidatableTest < ActiveSupport::TestCase
   test 'should require uniqueness of email if email has changed, allowing blank' do
     existing_user = create_user
 
-    user = new_user(:email => '')
+    user = new_user(email: '')
     assert user.invalid?
     assert_no_match(/taken/, user.errors[:email].join)
 
@@ -20,48 +22,44 @@ class ValidatableTest < ActiveSupport::TestCase
     assert user.invalid?
     assert_match(/taken/, user.errors[:email].join)
 
-    user.save(:validate => false)
+    user.save(validate: false)
     assert user.valid?
   end
 
   test 'should require correct email format if email has changed, allowing blank' do
-    user = new_user(:email => '')
+    user = new_user(email: '')
     assert user.invalid?
     assert_not_equal 'is invalid', user.errors[:email].join
 
-    %w{invalid_email_format 123 $$$ () ☃ bla@bla.}.each do |email|
+    %w{invalid_email_format 123 $$$ () ☃}.each do |email|
       user.email = email
-      assert user.invalid?, 'should be invalid with email ' << email
+      assert user.invalid?, "should be invalid with email #{email}"
       assert_equal 'is invalid', user.errors[:email].join
     end
 
-    user.save(:validate => false)
+    user.save(validate: false)
     assert user.valid?
   end
 
   test 'should accept valid emails' do
     %w(a.b.c@example.com test_mail@gmail.com any@any.net email@test.br 123@mail.test 1☃3@mail.test).each do |email|
-      user = new_user(:email => email)
-      assert user.valid?, 'should be valid with email ' << email
+      user = new_user(email: email)
+      assert user.valid?, "should be valid with email #{email}"
       assert_blank user.errors[:email]
     end
   end
 
   test 'should require password to be set when creating a new record' do
-    user = new_user(:password => '', :password_confirmation => '')
+    user = new_user(password: '', password_confirmation: '')
     assert user.invalid?
     assert_equal 'can\'t be blank', user.errors[:password].join
   end
 
   test 'should require confirmation to be set when creating a new record' do
-    user = new_user(:password => 'new_password', :password_confirmation => 'blabla')
+    user = new_user(password: 'new_password', password_confirmation: 'blabla')
     assert user.invalid?
 
-    if Devise.rails4?
-      assert_equal 'doesn\'t match Password', user.errors[:password_confirmation].join
-    else
-      assert_equal 'doesn\'t match confirmation', user.errors[:password].join
-    end
+    assert_equal 'doesn\'t match Password', user.errors[:password_confirmation].join
   end
 
   test 'should require password when updating/resetting password' do
@@ -79,23 +77,19 @@ class ValidatableTest < ActiveSupport::TestCase
     user.password_confirmation = 'another_password'
     assert user.invalid?
 
-    if Devise.rails4?
-      assert_equal 'doesn\'t match Password', user.errors[:password_confirmation].join
-    else
-      assert_equal 'doesn\'t match confirmation', user.errors[:password].join
-    end
+    assert_equal 'doesn\'t match Password', user.errors[:password_confirmation].join
   end
 
-  test 'should require a password with minimum of 6 characters' do
-    user = new_user(:password => '12345', :password_confirmation => '12345')
+  test 'should require a password with minimum of 7 characters' do
+    user = new_user(password: '12345', password_confirmation: '12345')
     assert user.invalid?
-    assert_equal 'is too short (minimum is 6 characters)', user.errors[:password].join
+    assert_equal 'is too short (minimum is 7 characters)', user.errors[:password].join
   end
 
-  test 'should require a password with maximum of 128 characters long' do
-    user = new_user(:password => 'x'*129, :password_confirmation => 'x'*129)
+  test 'should require a password with maximum of 72 characters long' do
+    user = new_user(password: 'x'*73, password_confirmation: 'x'*73)
     assert user.invalid?
-    assert_equal 'is too long (maximum is 128 characters)', user.errors[:password].join
+    assert_equal 'is too long (maximum is 72 characters)', user.errors[:password].join
   end
 
   test 'should not require password length when it\'s not changed' do
@@ -105,14 +99,14 @@ class ValidatableTest < ActiveSupport::TestCase
 
     user.password_confirmation = 'confirmation'
     assert user.invalid?
-    assert_not (user.errors[:password].join =~ /is too long/)
+    refute (user.errors[:password].join =~ /is too long/)
   end
 
   test 'should complain about length even if password is not required' do
-    user = new_user(:password => 'x'*129, :password_confirmation => 'x'*129)
+    user = new_user(password: 'x'*73, password_confirmation: 'x'*73)
     user.stubs(:password_required?).returns(false)
     assert user.invalid?
-    assert_equal 'is too long (maximum is 128 characters)', user.errors[:password].join
+    assert_equal 'is too long (maximum is 72 characters)', user.errors[:password].join
   end
 
   test 'should not be included in objects with invalid API' do

data/test/models_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 require 'test_models'
 
@@ -13,7 +15,7 @@ class ActiveRecordTest < ActiveSupport::TestCase
     end
 
     (Devise::ALL - modules).each do |mod|
-      assert_not include_module?(klass, mod)
+      refute include_module?(klass, mod)
     end
   end
 
@@ -92,20 +94,27 @@ class ActiveRecordTest < ActiveSupport::TestCase
   end
 end
 
+module StubModelFilters
+  def stub_filter(name)
+    define_singleton_method(name) { |*| nil }
+  end
+end
+
 class CheckFieldsTest < ActiveSupport::TestCase
   test 'checks if the class respond_to the required fields' do
     Player = Class.new do
       extend Devise::Models
+      extend StubModelFilters
 
-      def self.before_validation(instance)
-      end
+      stub_filter :before_validation
+      stub_filter :after_update
 
       devise :database_authenticatable
 
       attr_accessor :encrypted_password, :email
     end
 
-    assert_nothing_raised Devise::Models::MissingAttribute do
+    assert_nothing_raised do
       Devise::Models.check_fields!(Player)
     end
   end
@@ -113,9 +122,10 @@ class CheckFieldsTest < ActiveSupport::TestCase
   test 'raises Devise::Models::MissingAtrribute and shows the missing attribute if the class doesn\'t respond_to one of the attributes' do
     Clown = Class.new do
       extend Devise::Models
+      extend StubModelFilters
 
-      def self.before_validation(instance)
-      end
+      stub_filter :before_validation
+      stub_filter :after_update
 
       devise :database_authenticatable
 
@@ -130,9 +140,10 @@ class CheckFieldsTest < ActiveSupport::TestCase
   test 'raises Devise::Models::MissingAtrribute with all the missing attributes if there is more than one' do
     Magician = Class.new do
       extend Devise::Models
+      extend StubModelFilters
 
-      def self.before_validation(instance)
-      end
+      stub_filter :before_validation
+      stub_filter :after_update
 
       devise :database_authenticatable
     end

data/test/omniauth/config_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class OmniAuthConfigTest < ActiveSupport::TestCase
@@ -11,12 +13,12 @@ class OmniAuthConfigTest < ActiveSupport::TestCase
   end
 
   test 'strategy_name returns provider if no name option are given' do
-    config = Devise::OmniAuth::Config.new :facebook, [{ :other => :option }]
+    config = Devise::OmniAuth::Config.new :facebook, [{ other: :option }]
     assert_equal :facebook, config.strategy_name
   end
 
   test 'returns name option when have a name' do
-    config = Devise::OmniAuth::Config.new :facebook, [{ :name => :github }]
+    config = Devise::OmniAuth::Config.new :facebook, [{ name: :github }]
     assert_equal :github, config.strategy_name
   end
 
@@ -25,19 +27,21 @@ class OmniAuthConfigTest < ActiveSupport::TestCase
     assert_equal OmniAuth::Strategies::Facebook, config.strategy_class
   end
 
-  test "finds the strategy in OmniAuth's list by name" do
-    NamedTestStrategy = Class.new
-    NamedTestStrategy.send :include, OmniAuth::Strategy
-    NamedTestStrategy.option :name, :the_one
+  class NamedTestStrategy
+    include OmniAuth::Strategy
+    option :name, :the_one
+  end
 
+  test "finds the strategy in OmniAuth's list by name" do
     config = Devise::OmniAuth::Config.new :the_one, [{}]
     assert_equal NamedTestStrategy, config.strategy_class
   end
 
-  test "finds the strategy in OmniAuth's list by class name" do
-    UnNamedTestStrategy = Class.new
-    UnNamedTestStrategy.send :include, OmniAuth::Strategy
+  class UnNamedTestStrategy
+    include OmniAuth::Strategy
+  end
 
+  test "finds the strategy in OmniAuth's list by class name" do
     config = Devise::OmniAuth::Config.new :un_named_test_strategy, [{}]
     assert_equal UnNamedTestStrategy, config.strategy_class
   end
@@ -50,8 +54,8 @@ class OmniAuthConfigTest < ActiveSupport::TestCase
   end
 
   test 'allows the user to define a custom require path' do
-    config = Devise::OmniAuth::Config.new :my_strategy, [{:strategy_class => MyStrategy}]
+    config = Devise::OmniAuth::Config.new :my_strategy, [{strategy_class: MyStrategy}]
     config_class = config.strategy_class
     assert_equal MyStrategy, config_class
   end
-end
+end

data/test/omniauth/url_helpers_test.rb

@@ -1,24 +1,23 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class OmniAuthRoutesTest < ActionController::TestCase
-  ExpectedUrlGeneratiorError = Devise.rails4? ?
-    ActionController::UrlGenerationError : ActionController::RoutingError
-
   tests ApplicationController
 
   def assert_path(action, provider, with_param=true)
     # Resource param
     assert_equal @controller.send(action, :user, provider),
-                 @controller.send("user_#{action}", provider)
+                 @controller.send("user_#{provider}_#{action}")
 
     # With an object
     assert_equal @controller.send(action, User.new, provider),
-                 @controller.send("user_#{action}", provider)
+                 @controller.send("user_#{provider}_#{action}")
 
     if with_param
       # Default url params
-      assert_equal @controller.send(action, :user, provider, :param => 123),
-                   @controller.send("user_#{action}", provider, :param => 123)
+      assert_equal @controller.send(action, :user, provider, param: 123),
+                   @controller.send("user_#{provider}_#{action}", param: 123)
     end
   end
 
@@ -33,7 +32,7 @@ class OmniAuthRoutesTest < ActionController::TestCase
   test 'should generate authorization path' do
     assert_match "/users/auth/facebook", @controller.omniauth_authorize_path(:user, :facebook)
 
-    assert_raise ExpectedUrlGeneratiorError do
+    assert_raise NoMethodError do
       @controller.omniauth_authorize_path(:user, :github)
     end
   end
@@ -44,7 +43,7 @@ class OmniAuthRoutesTest < ActionController::TestCase
 
   test 'should generate authorization path with params' do
     assert_match "/users/auth/openid?openid_url=http%3A%2F%2Fyahoo.com",
-                  @controller.omniauth_authorize_path(:user, :openid, :openid_url => "http://yahoo.com")
+                  @controller.omniauth_authorize_path(:user, :openid, openid_url: "http://yahoo.com")
   end
 
   test 'should not add a "?" if no param was sent' do