authlogic 3.4.6 → 4.2.0

data/test/acts_as_authentic_test/perishable_token_test.rb

@@ -1,81 +1,87 @@
-require 'test_helper'
+require "test_helper"
 
 module ActsAsAuthenticTest
   class PerishableTokenTest < ActiveSupport::TestCase
     def test_perishable_token_valid_for_config
       assert_equal 10.minutes.to_i, User.perishable_token_valid_for
       assert_equal 10.minutes.to_i, Employee.perishable_token_valid_for
-      
+
       User.perishable_token_valid_for = 1.hour
       assert_equal 1.hour.to_i, User.perishable_token_valid_for
       User.perishable_token_valid_for 10.minutes
       assert_equal 10.minutes.to_i, User.perishable_token_valid_for
     end
-    
+
     def test_disable_perishable_token_maintenance_config
-      assert !User.disable_perishable_token_maintenance
-      assert !Employee.disable_perishable_token_maintenance
-      
+      refute User.disable_perishable_token_maintenance
+      refute Employee.disable_perishable_token_maintenance
+
       User.disable_perishable_token_maintenance = true
       assert User.disable_perishable_token_maintenance
       User.disable_perishable_token_maintenance false
-      assert !User.disable_perishable_token_maintenance
+      refute User.disable_perishable_token_maintenance
     end
-    
+
     def test_validates_uniqueness_of_perishable_token
       u = User.new
       u.perishable_token = users(:ben).perishable_token
-      assert !u.valid?
-      assert u.errors[:perishable_token].size > 0
+      refute u.valid?
+      refute u.errors[:perishable_token].empty?
     end
-    
+
     def test_before_save_reset_perishable_token
       ben = users(:ben)
       old_perishable_token = ben.perishable_token
       assert ben.save
       assert_not_equal old_perishable_token, ben.perishable_token
     end
-    
+
     def test_reset_perishable_token
       ben = users(:ben)
       old_perishable_token = ben.perishable_token
-      
+
       assert ben.reset_perishable_token
       assert_not_equal old_perishable_token, ben.perishable_token
-      
+
       ben.reload
       assert_equal old_perishable_token, ben.perishable_token
-      
+
       assert ben.reset_perishable_token!
       assert_not_equal old_perishable_token, ben.perishable_token
-      
+
       ben.reload
       assert_not_equal old_perishable_token, ben.perishable_token
     end
-    
+
     def test_find_using_perishable_token
       ben = users(:ben)
       assert_equal ben, User.find_using_perishable_token(ben.perishable_token)
     end
-    
+
     def test_find_using_perishable_token_when_perished
       ben = users(:ben)
-      ActiveRecord::Base.connection.execute("UPDATE users set updated_at = '#{1.week.ago.to_s(:db)}' where id = #{ben.id}")
+      ActiveRecord::Base.connection.execute(
+        "UPDATE users set updated_at = '#{1.week.ago.to_s(:db)}' where id = #{ben.id}"
+      )
       assert_nil User.find_using_perishable_token(ben.perishable_token)
     end
-    
-    def test_find_using_perishable_token_when_perished
+
+    def test_find_using_perishable_token_when_perished_2
       User.perishable_token_valid_for = 1.minute
       ben = users(:ben)
-      ActiveRecord::Base.connection.execute("UPDATE users set updated_at = '#{2.minutes.ago.to_s(:db)}' where id = #{ben.id}")
+      ActiveRecord::Base.connection.execute(
+        "UPDATE users set updated_at = '#{2.minutes.ago.to_s(:db)}' where id = #{ben.id}"
+      )
       assert_nil User.find_using_perishable_token(ben.perishable_token)
       User.perishable_token_valid_for = 10.minutes
     end
-    
+
     def test_find_using_perishable_token_when_passing_threshold
       User.perishable_token_valid_for = 1.minute
       ben = users(:ben)
-      ActiveRecord::Base.connection.execute("UPDATE users set updated_at = '#{10.minutes.ago.to_s(:db)}' where id = #{ben.id}")
+      ActiveRecord::Base.connection.execute(
+        "UPDATE users set updated_at = '#{10.minutes.ago.to_s(:db)}' where id = #{ben.id}"
+      )
       assert_nil User.find_using_perishable_token(ben.perishable_token, 5.minutes)
       assert_equal ben, User.find_using_perishable_token(ben.perishable_token, 20.minutes)
       User.perishable_token_valid_for = 10.minutes
@@ -83,7 +89,7 @@ module ActsAsAuthenticTest
 
     def test_find_perishable_token_with_bang
       assert_raises ActiveRecord::RecordNotFound do
-        User.find_using_perishable_token!('some_bad_value')
+        User.find_using_perishable_token!("some_bad_value")
       end
     end
   end

data/test/acts_as_authentic_test/persistence_token_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 module ActsAsAuthenticTest
   class PersistenceTokenTest < ActiveSupport::TestCase
@@ -24,21 +24,25 @@ module ActsAsAuthenticTest
 
     def test_before_validate_reset_persistence_token
       u = User.new
-      assert !u.valid?
+      refute u.valid?
       assert_not_nil u.persistence_token
     end
 
     def test_forget_all
+      UserSession.allow_http_basic_auth = true
+
       http_basic_auth_for(users(:ben)) { UserSession.find }
       http_basic_auth_for(users(:zack)) { UserSession.find(:ziggity_zack) }
       assert UserSession.find
       assert UserSession.find(:ziggity_zack)
       User.forget_all
-      assert !UserSession.find
-      assert !UserSession.find(:ziggity_zack)
+      refute UserSession.find
+      refute UserSession.find(:ziggity_zack)
     end
 
     def test_forget
+      UserSession.allow_http_basic_auth = true
+
       ben = users(:ben)
       zack = users(:zack)
       http_basic_auth_for(ben) { UserSession.find }
@@ -49,7 +53,7 @@ module ActsAsAuthenticTest
 
       ben.forget!
 
-      assert !UserSession.find
+      refute UserSession.find
       assert UserSession.find(:ziggity_zack)
     end
   end

data/test/acts_as_authentic_test/restful_authentication_test.rb

@@ -1,37 +1,46 @@
-require 'test_helper'
+require "test_helper"
 
 module ActsAsAuthenticTest
   class RestfulAuthenticationTest < ActiveSupport::TestCase
+    def setup
+      @old_deprecation_behavior = ::ActiveSupport::Deprecation.behavior
+      ::ActiveSupport::Deprecation.behavior = :silence
+    end
+
+    def teardown
+      ::ActiveSupport::Deprecation.behavior = @old_deprecation_behavior
+    end
+
     def test_act_like_restful_authentication_config
-      assert !User.act_like_restful_authentication
-      assert !Employee.act_like_restful_authentication
+      refute User.act_like_restful_authentication
+      refute Employee.act_like_restful_authentication
 
       User.act_like_restful_authentication = true
       assert User.act_like_restful_authentication
       assert_equal Authlogic::CryptoProviders::Sha1, User.crypto_provider
       assert defined?(::REST_AUTH_SITE_KEY)
-      assert_equal '', ::REST_AUTH_SITE_KEY
+      assert_equal "", ::REST_AUTH_SITE_KEY
       assert_equal 1, Authlogic::CryptoProviders::Sha1.stretches
 
       User.act_like_restful_authentication false
-      assert !User.act_like_restful_authentication
+      refute User.act_like_restful_authentication
 
       User.crypto_provider = Authlogic::CryptoProviders::Sha512
       User.transition_from_crypto_providers = []
     end
 
     def test_transition_from_restful_authentication_config
-      assert !User.transition_from_restful_authentication
-      assert !Employee.transition_from_restful_authentication
+      refute User.transition_from_restful_authentication
+      refute Employee.transition_from_restful_authentication
 
       User.transition_from_restful_authentication = true
       assert User.transition_from_restful_authentication
       assert defined?(::REST_AUTH_SITE_KEY)
-      assert_equal '', ::REST_AUTH_SITE_KEY
+      assert_equal "", ::REST_AUTH_SITE_KEY
       assert_equal 1, Authlogic::CryptoProviders::Sha1.stretches
 
       User.transition_from_restful_authentication false
-      assert !User.transition_from_restful_authentication
+      refute User.transition_from_restful_authentication
     end
   end
 end

data/test/acts_as_authentic_test/session_maintenance_test.rb

@@ -1,35 +1,78 @@
-require 'test_helper'
+require "test_helper"
 
 module ActsAsAuthenticTest
   class SessionMaintenanceTest < ActiveSupport::TestCase
-    def test_maintain_sessions_config
-      assert User.maintain_sessions
-      User.maintain_sessions = false
-      assert !User.maintain_sessions
-      User.maintain_sessions true
-      assert User.maintain_sessions
+    def setup
+      User.log_in_after_create = true
+      User.log_in_after_password_change = true
     end
-    
+
+    def test_log_in_after_create_config
+      assert User.log_in_after_create
+      User.log_in_after_create = false
+      refute User.log_in_after_create
+      User.log_in_after_create = true
+      assert User.log_in_after_create
+    end
+
+    def test_log_in_after_password_change_config
+      assert User.log_in_after_password_change
+      User.log_in_after_password_change = false
+      refute User.log_in_after_password_change
+      User.log_in_after_password_change = true
+      assert User.log_in_after_password_change
+    end
+
     def test_login_after_create
-      assert User.create(:login => "awesome", :password => "saweet", :password_confirmation => "saweet", :email => "awesome@awesome.com")
+      User.log_in_after_create = true
+      user = User.create(
+        login: "awesome",
+        password: "saweeeet",
+        password_confirmation: "saweeeet",
+        email: "awesome@awesome.com"
+      )
+      assert user.persisted?
       assert UserSession.find
+      logged_in_user = UserSession.find.user
+      assert_equal logged_in_user, user
     end
-    
+
+    def test_no_login_after_create
+      old_user = User.create(
+        login: "awesome",
+        password: "saweeeet",
+        password_confirmation: "saweeeet",
+        email: "awesome@awesome.com"
+      )
+      User.log_in_after_create = false
+      user2 = User.create(
+        login: "awesome2",
+        password: "saweeeet2",
+        password_confirmation: "saweeeet2",
+        email: "awesome2@awesome.com"
+      )
+      assert user2.persisted?
+      logged_in_user = UserSession.find.user
+      assert_not_equal logged_in_user, user2
+      assert_equal logged_in_user, old_user
+    end
+
     def test_updating_session_with_failed_magic_state
       ben = users(:ben)
       ben.confirmed = false
-      ben.password = "newpass"
-      ben.password_confirmation = "newpass"
+      ben.password = "newpasswd"
+      ben.password_confirmation = "newpasswd"
       assert ben.save
     end
 
     def test_update_session_after_password_modify
+      User.log_in_after_password_change = true
       ben = users(:ben)
       UserSession.create(ben)
       old_session_key = controller.session["user_credentials"]
       old_cookie_key = controller.cookies["user_credentials"]
-      ben.password = "newpass"
-      ben.password_confirmation = "newpass"
+      ben.password = "newpasswd"
+      ben.password_confirmation = "newpasswd"
       assert ben.save
       assert controller.session["user_credentials"]
       assert controller.cookies["user_credentials"]
@@ -37,6 +80,21 @@ module ActsAsAuthenticTest
       assert_not_equal controller.cookies["user_credentials"], old_cookie_key
     end
 
+    def test_no_update_session_after_password_modify
+      User.log_in_after_password_change = false
+      ben = users(:ben)
+      UserSession.create(ben)
+      old_session_key = controller.session["user_credentials"]
+      old_cookie_key = controller.cookies["user_credentials"]
+      ben.password = "newpasswd"
+      ben.password_confirmation = "newpasswd"
+      assert ben.save
+      assert controller.session["user_credentials"]
+      assert controller.cookies["user_credentials"]
+      assert_equal controller.session["user_credentials"], old_session_key
+      assert_equal controller.cookies["user_credentials"], old_cookie_key
+    end
+
     def test_no_session_update_after_modify
       ben = users(:ben)
       UserSession.create(ben)
@@ -47,13 +105,19 @@ module ActsAsAuthenticTest
       assert_equal controller.session["user_credentials"], old_session_key
       assert_equal controller.cookies["user_credentials"], old_cookie_key
     end
-    
+
     def test_creating_other_user
       ben = users(:ben)
       UserSession.create(ben)
       old_session_key = controller.session["user_credentials"]
       old_cookie_key = controller.cookies["user_credentials"]
-      assert User.create(:login => "awesome", :password => "saweet", :password_confirmation => "saweet", :email => "awesome@saweet.com")
+      user = User.create(
+        login: "awesome",
+        password: "saweet", # Password is too short, user invalid
+        password_confirmation: "saweet",
+        email: "awesome@saweet.com"
+      )
+      refute user.persisted?
       assert_equal controller.session["user_credentials"], old_session_key
       assert_equal controller.cookies["user_credentials"], old_cookie_key
     end
@@ -64,8 +128,8 @@ module ActsAsAuthenticTest
       old_session_key = controller.session["user_credentials"]
       old_cookie_key = controller.cookies["user_credentials"]
       zack = users(:zack)
-      zack.password = "newpass"
-      zack.password_confirmation = "newpass"
+      zack.password = "newpasswd"
+      zack.password_confirmation = "newpasswd"
       assert zack.save
       assert_equal controller.session["user_credentials"], old_session_key
       assert_equal controller.cookies["user_credentials"], old_cookie_key
@@ -73,12 +137,12 @@ module ActsAsAuthenticTest
 
     def test_resetting_password_when_logged_out
       ben = users(:ben)
-      assert !UserSession.find
-      ben.password = "newpass"
-      ben.password_confirmation = "newpass"
+      refute UserSession.find
+      ben.password = "newpasswd"
+      ben.password_confirmation = "newpasswd"
       assert ben.save
       assert UserSession.find
       assert_equal ben, UserSession.find.record
     end
   end
-end
+end

data/test/acts_as_authentic_test/single_access_test.rb

@@ -1,44 +1,44 @@
-require 'test_helper'
+require "test_helper"
 
 module ActsAsAuthenticTest
   class SingleAccessTest < ActiveSupport::TestCase
     def test_change_single_access_token_with_password_config
-      assert !User.change_single_access_token_with_password
-      assert !Employee.change_single_access_token_with_password
-      
+      refute User.change_single_access_token_with_password
+      refute Employee.change_single_access_token_with_password
+
       User.change_single_access_token_with_password = true
       assert User.change_single_access_token_with_password
       User.change_single_access_token_with_password false
-      assert !User.change_single_access_token_with_password
+      refute User.change_single_access_token_with_password
     end
-    
+
     def test_validates_uniqueness_of_single_access_token
       u = User.new
       u.single_access_token = users(:ben).single_access_token
-      assert !u.valid?
-      assert u.errors[:single_access_token].size > 0
+      refute u.valid?
+      refute u.errors[:single_access_token].empty?
     end
-    
+
     def test_before_validation_reset_single_access_token
       u = User.new
-      assert !u.valid?
+      refute u.valid?
       assert_not_nil u.single_access_token
     end
-    
+
     def test_after_password_set_reset_single_access_token
       User.change_single_access_token_with_password = true
-      
+
       ben = users(:ben)
       old_single_access_token = ben.single_access_token
       ben.password = "new_pass"
       assert_not_equal old_single_access_token, ben.single_access_token
-      
+
       User.change_single_access_token_with_password = false
     end
-    
+
     def test_after_password_set_is_not_called
       ldaper = Ldaper.new
       assert ldaper.save
     end
   end
-end
+end

data/test/adapter_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+module Authlogic
+  module ControllerAdapters
+    class AbstractAdapterTest < ActiveSupport::TestCase
+      def test_controller
+        controller = Class.new(MockController) do
+          def controller.an_arbitrary_method
+            "bar"
+          end
+        end.new
+        adapter = Authlogic::ControllerAdapters::AbstractAdapter.new(controller)
+
+        assert_equal controller, adapter.controller
+        assert controller.params.equal?(adapter.params)
+        assert adapter.respond_to?(:an_arbitrary_method)
+        assert_equal "bar", adapter.an_arbitrary_method
+      end
+    end
+  end
+end