authlogic 2.0.1 → 2.1.2

data/test/acts_as_authentic_test/session_maintenance_test.rb

@@ -2,6 +2,14 @@ require File.dirname(__FILE__) + '/../test_helper.rb'
 
 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
+    end
+    
     def test_login_after_create
       assert User.create(:login => "awesome", :password => "saweet", :password_confirmation => "saweet", :email => "awesome@awesome.com")
       assert UserSession.find
@@ -18,49 +26,49 @@ module ActsAsAuthenticTest
     def test_update_session_after_password_modify
       ben = users(:ben)
       UserSession.create(ben)
-      old_session_key = @controller.session["user_credentials"]
-      old_cookie_key = @controller.cookies["user_credentials"]
+      old_session_key = controller.session["user_credentials"]
+      old_cookie_key = controller.cookies["user_credentials"]
       ben.password = "newpass"
       ben.password_confirmation = "newpass"
       assert ben.save
-      assert @controller.session["user_credentials"]
-      assert @controller.cookies["user_credentials"]
-      assert_not_equal @controller.session["user_credentials"], old_session_key
-      assert_not_equal @controller.cookies["user_credentials"], old_cookie_key
+      assert controller.session["user_credentials"]
+      assert controller.cookies["user_credentials"]
+      assert_not_equal controller.session["user_credentials"], old_session_key
+      assert_not_equal controller.cookies["user_credentials"], old_cookie_key
     end
 
     def test_no_session_update_after_modify
       ben = users(:ben)
       UserSession.create(ben)
-      old_session_key = @controller.session["user_credentials"]
-      old_cookie_key = @controller.cookies["user_credentials"]
+      old_session_key = controller.session["user_credentials"]
+      old_cookie_key = controller.cookies["user_credentials"]
       ben.first_name = "Ben"
       assert ben.save
-      assert_equal @controller.session["user_credentials"], old_session_key
-      assert_equal @controller.cookies["user_credentials"], old_cookie_key
+      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"]
+      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")
-      assert_equal @controller.session["user_credentials"], old_session_key
-      assert_equal @controller.cookies["user_credentials"], old_cookie_key
+      assert_equal controller.session["user_credentials"], old_session_key
+      assert_equal controller.cookies["user_credentials"], old_cookie_key
     end
 
     def test_updating_other_user
       ben = users(:ben)
       UserSession.create(ben)
-      old_session_key = @controller.session["user_credentials"]
-      old_cookie_key = @controller.cookies["user_credentials"]
+      old_session_key = controller.session["user_credentials"]
+      old_cookie_key = controller.cookies["user_credentials"]
       zack = users(:zack)
       zack.password = "newpass"
       zack.password_confirmation = "newpass"
       assert zack.save
-      assert_equal @controller.session["user_credentials"], old_session_key
-      assert_equal @controller.cookies["user_credentials"], old_cookie_key
+      assert_equal controller.session["user_credentials"], old_session_key
+      assert_equal controller.cookies["user_credentials"], old_cookie_key
     end
 
     def test_resetting_password_when_logged_out

data/test/acts_as_authentic_test/single_access_test.rb

@@ -16,7 +16,7 @@ module ActsAsAuthenticTest
       u = User.new
       u.single_access_token = users(:ben).single_access_token
       assert !u.valid?
-      assert u.errors.on(:single_access_token)
+      assert u.errors[:single_access_token].size > 0
     end
     
     def test_before_validation_reset_single_access_token
@@ -35,5 +35,10 @@ module ActsAsAuthenticTest
       
       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

data/test/i18n_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class I18nTest < ActiveSupport::TestCase
+  def test_uses_authlogic_as_scope_by_default
+    assert_equal :authlogic, Authlogic::I18n.scope
+  end
+  
+  def test_can_set_scope
+    assert_nothing_raised { Authlogic::I18n.scope = [:a, :b] }
+    assert_equal [:a, :b], Authlogic::I18n.scope
+    Authlogic::I18n.scope = :authlogic
+  end
+  
+  def test_uses_built_in_translator_by_default
+    assert_equal Authlogic::I18n::Translator, Authlogic::I18n.translator.class
+  end
+  
+  def test_can_set_custom_translator
+    old_translator = Authlogic::I18n.translator
+    
+    assert_nothing_raised do
+      Authlogic::I18n.translator = Class.new do
+        def translate(key, options = {})
+          "Translated: #{key}"
+        end
+      end.new
+    end
+
+    assert_equal "Translated: x", Authlogic::I18n.translate(:x)
+    
+    Authlogic::I18n.translator = old_translator
+  end
+end

data/test/libs/affiliate.rb

@@ -0,0 +1,7 @@
+class Affiliate < ActiveRecord::Base
+  acts_as_authentic do |c|
+    c.crypted_password_field = :pw_hash
+  end
+  
+  belongs_to :company
+end

data/test/libs/ldaper.rb

@@ -0,0 +1,3 @@
+class Ldaper < ActiveRecord::Base
+  acts_as_authentic
+end

data/test/random_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
+require File.dirname(__FILE__) + '/test_helper.rb'
 
 class RandomTest < ActiveSupport::TestCase
   def test_random_tokens_have_consisten_length
@@ -36,7 +36,7 @@ class RandomTest < ActiveSupport::TestCase
     def reload_authlogic_with_sec_random!(secure_random, enabled = true)
       silence_warnings do
         secure_random.parent.const_set(secure_random.name.sub("#{secure_random.parent}::", ''), enabled ? secure_random : nil)
-        load(File.dirname(__FILE__) + '/../../lib/authlogic/random.rb')
+        load(File.dirname(__FILE__) + '/../lib/authlogic/random.rb')
       end
     end
 

data/test/session_test/activation_test.rb

@@ -36,7 +36,7 @@ module SessionTest
       def test_init
         UserSession.controller = nil
         assert_raise(Authlogic::Session::Activation::NotActivatedError) { UserSession.new }
-        UserSession.controller = @controller
+        UserSession.controller = controller
       end
     end
   end

data/test/session_test/active_record_trickery_test.rb

@@ -5,15 +5,20 @@ module SessionTest
     class ClassMethodsTest < ActiveSupport::TestCase
       def test_human_attribute_name
         assert_equal "Some attribute", UserSession.human_attribute_name("some_attribute")
+        assert_equal "Some attribute", UserSession.human_attribute_name(:some_attribute)
       end
     
       def test_human_name
-        assert_equal "User", UserSession.human_name
+        assert_equal "Usersession", UserSession.human_name
       end
     
       def test_self_and_descendents_from_active_record
         assert_equal [UserSession], UserSession.self_and_descendents_from_active_record
       end
+    
+      def test_self_and_descendants_from_active_record
+        assert_equal [UserSession], UserSession.self_and_descendants_from_active_record
+      end
     end
     
     class InstanceMethodsTest < ActiveSupport::TestCase
@@ -21,6 +26,11 @@ module SessionTest
         session = UserSession.new
         assert session.new_record?
       end
+      
+      def test_to_model
+        session = UserSession.new
+        assert session, session.to_model
+      end
     end
   end
-end
+end

data/test/session_test/brute_force_protection_test.rb

@@ -32,10 +32,10 @@ module SessionTest
         ben = users(:ben)
         ben.failed_login_count = UserSession.consecutive_failed_logins_limit
         assert ben.save
-        assert !UserSession.create(:login => ben.login, :password => "benrocks")
-        assert !UserSession.create(ben)
+        assert UserSession.create(:login => ben.login, :password => "benrocks").new_session?
+        assert UserSession.create(ben).new_session?
         ben.updated_at = (UserSession.failed_login_ban_for + 2.hours.to_i).seconds.ago
-        assert UserSession.create(ben)
+        assert !UserSession.create(ben).new_session?
       end
     
       def test_exceeding_failed_logins_limit
@@ -45,31 +45,56 @@ module SessionTest
         2.times do |i|
           session = UserSession.new(:login => ben.login, :password => "badpassword1")
           assert !session.save
-          assert session.errors.on(:password)
+          assert session.errors[:password].size > 0
           assert_equal i + 1, ben.reload.failed_login_count
         end
-      
+        
         session = UserSession.new(:login => ben.login, :password => "badpassword2")
         assert !session.save
-        assert !session.errors.on(:password)
-        assert_equal 2, ben.reload.failed_login_count
+        assert session.errors[:password].size == 0
+        assert_equal 3, ben.reload.failed_login_count
       
         UserSession.consecutive_failed_logins_limit = 50
       end
-    
-      def test_resetting_failed_logins_count
+      
+      def test_exceeded_ban_for
+        UserSession.consecutive_failed_logins_limit = 2
+        UserSession.generalize_credentials_error_messages true
         ben = users(:ben)
       
         2.times do |i|
-          session = UserSession.new(:login => ben.login, :password => "badpassword")
+          session = UserSession.new(:login => ben.login, :password => "badpassword1")
           assert !session.save
-          assert session.errors.on(:password)
+          assert session.invalid_password?
           assert_equal i + 1, ben.reload.failed_login_count
         end
-      
+        
+        ActiveRecord::Base.connection.execute("update users set updated_at = '#{1.day.ago.to_s(:db)}' where login = '#{ben.login}'")
         session = UserSession.new(:login => ben.login, :password => "benrocks")
         assert session.save
         assert_equal 0, ben.reload.failed_login_count
+      
+        UserSession.consecutive_failed_logins_limit = 50
+        UserSession.generalize_credentials_error_messages false
+      end
+
+      def test_exceeded_ban_and_failed_doesnt_ban_again
+        UserSession.consecutive_failed_logins_limit = 2
+        ben = users(:ben)
+      
+        2.times do |i|
+          session = UserSession.new(:login => ben.login, :password => "badpassword1")
+          assert !session.save
+          assert session.errors[:password].size > 0
+          assert_equal i + 1, ben.reload.failed_login_count
+        end
+        
+        ActiveRecord::Base.connection.execute("update users set updated_at = '#{1.day.ago.to_s(:db)}' where login = '#{ben.login}'")
+        session = UserSession.new(:login => ben.login, :password => "badpassword1")
+        assert !session.save
+        assert_equal 1, ben.reload.failed_login_count
+      
+        UserSession.consecutive_failed_logins_limit = 50
       end
     end
   end

data/test/session_test/cookies_test.rb

@@ -91,16 +91,16 @@ module SessionTest
         ben = users(:ben)
         session = UserSession.new(ben)
         assert session.save
-        assert_equal ben.persistence_token, @controller.cookies["user_credentials"]
+        assert_equal "#{ben.persistence_token}::#{ben.id}", controller.cookies["user_credentials"]
       end
     
       def test_after_destroy_destroy_cookie
         ben = users(:ben)
         set_cookie_for(ben)
         session = UserSession.find
-        assert @controller.cookies["user_credentials"]
+        assert controller.cookies["user_credentials"]
         assert session.destroy
-        assert !@controller.cookies["user_credentials"]
+        assert !controller.cookies["user_credentials"]
       end
     end
   end

data/test/session_test/existence_test.rb

@@ -5,10 +5,10 @@ module SessionTest
     class ClassMethodsTest < ActiveSupport::TestCase
       def test_create
         ben = users(:ben)
-        assert !UserSession.create(:login => "somelogin", :password => "badpw2")
-        assert UserSession.create(:login => ben.login, :password => "benrocks")
+        assert UserSession.create(:login => "somelogin", :password => "badpw2").new_session?
+        assert !UserSession.create(:login => ben.login, :password => "benrocks").new_session?
         assert_raise(Authlogic::Session::Existence::SessionInvalidError) { UserSession.create!(:login => ben.login, :password => "badpw") }
-        assert UserSession.create!(:login => ben.login, :password => "benrocks")
+        assert !UserSession.create!(:login => ben.login, :password => "benrocks").new_session?
       end
     end
     

data/test/session_test/http_auth_test.rb

@@ -2,14 +2,26 @@ require File.dirname(__FILE__) + '/../test_helper.rb'
 
 module SessionTest
   class HttpAuthTest < ActiveSupport::TestCase
-    def test_persist_persist_by_http_auth
-      ben = users(:ben)
-      http_basic_auth_for { assert !UserSession.find }
-      http_basic_auth_for(ben) do
-        assert session = UserSession.find
-        assert_equal ben, session.record
-        assert_equal ben.login, session.login
-        assert_equal "benrocks", session.send(:protected_password)
+    class ConfiTest < ActiveSupport::TestCase
+      def test_allow_http_basic_auth
+        UserSession.allow_http_basic_auth = false
+        assert_equal false, UserSession.allow_http_basic_auth
+    
+        UserSession.allow_http_basic_auth true
+        assert_equal true, UserSession.allow_http_basic_auth
+      end
+    end
+    
+    class InstanceMethodsTest < ActiveSupport::TestCase
+      def test_persist_persist_by_http_auth
+        ben = users(:ben)
+        http_basic_auth_for { assert !UserSession.find }
+        http_basic_auth_for(ben) do
+          assert session = UserSession.find
+          assert_equal ben, session.record
+          assert_equal ben.login, session.login
+          assert_equal "benrocks", session.send(:protected_password)
+        end
       end
     end
   end

data/test/session_test/magic_columns_test.rb

@@ -15,6 +15,8 @@ module SessionTest
     class InstanceMethodsTest < ActiveSupport::TestCase
       def test_after_persisting_set_last_request_at
         ben = users(:ben)
+        assert !UserSession.create(ben).new_session?
+        
         set_cookie_for(ben)
         old_last_request_at = ben.last_request_at
         assert UserSession.find
@@ -22,10 +24,10 @@ module SessionTest
         assert ben.last_request_at != old_last_request_at
       end
     
-      def test_valide_increase_failed_login_count
+      def test_valid_increase_failed_login_count
         ben = users(:ben)
         old_failed_login_count = ben.failed_login_count
-        assert !UserSession.create(:login => ben.login, :password => "wrong")
+        assert UserSession.create(:login => ben.login, :password => "wrong").new_session?
         ben.reload
         assert_equal old_failed_login_count + 1, ben.failed_login_count
       end
@@ -34,7 +36,7 @@ module SessionTest
         ben = users(:ben)
       
         # increase failed login count
-        assert !UserSession.create(:login => ben.login, :password => "wrong")
+        assert UserSession.create(:login => ben.login, :password => "wrong").new_session?
         ben.reload
       
         # grab old values
@@ -45,10 +47,11 @@ module SessionTest
         old_last_login_ip = ben.last_login_ip
         old_current_login_ip = ben.current_login_ip
       
-        assert UserSession.create(ben)
-      
+        assert !UserSession.create(:login => ben.login, :password => "benrocks").new_session?
+        
+        ben.reload
         assert_equal old_login_count + 1, ben.login_count
-        assert_equal old_failed_login_count - 1, ben.failed_login_count
+        assert_equal 0, ben.failed_login_count
         assert_equal old_current_login_at, ben.last_login_at
         assert ben.current_login_at != old_current_login_at
         assert_equal old_current_login_ip, ben.last_login_ip

data/test/session_test/magic_states_test.rb

@@ -31,7 +31,7 @@ module SessionTest
       
         ben.update_attribute(:active, false)
         assert !session.valid?
-        assert session.errors.on_base.size > 0
+        assert session.errors[:base].size > 0
       end
     
       def test_validate_validate_magic_states_approved
@@ -42,7 +42,7 @@ module SessionTest
       
         ben.update_attribute(:approved, false)
         assert !session.valid?
-        assert session.errors.on_base.size > 0
+        assert session.errors[:base].size > 0
       end
     
       def test_validate_validate_magic_states_confirmed
@@ -53,7 +53,7 @@ module SessionTest
       
         ben.update_attribute(:confirmed, false)
         assert !session.valid?
-        assert session.errors.on_base.size > 0
+        assert session.errors[:base].size > 0
       end
     end
   end

data/test/session_test/params_test.rb

@@ -31,22 +31,22 @@ module SessionTest
         assert !session.persisting?
         assert !session.unauthorized_record
         assert !session.record
-        assert_nil @controller.session["user_credentials"]
+        assert_nil controller.session["user_credentials"]
       
         set_request_content_type("text/plain")
         assert !session.persisting?
         assert !session.unauthorized_record
-        assert_nil @controller.session["user_credentials"]
+        assert_nil controller.session["user_credentials"]
       
         set_request_content_type("application/atom+xml")
         assert session.persisting?
         assert_equal ben, session.record
-        assert_nil @controller.session["user_credentials"] # should not persist since this is single access
+        assert_nil controller.session["user_credentials"] # should not persist since this is single access
       
         set_request_content_type("application/rss+xml")
         assert session.persisting?
         assert_equal ben, session.unauthorized_record
-        assert_nil @controller.session["user_credentials"]
+        assert_nil controller.session["user_credentials"]
       end
     end
   end

data/test/session_test/password_test.rb

@@ -19,6 +19,28 @@ module SessionTest
         assert_equal "valid_password?", UserSession.verify_password_method
       end
     
+      def test_generalize_credentials_error_mesages_set_to_false
+        UserSession.generalize_credentials_error_messages false
+        assert !UserSession.generalize_credentials_error_messages
+        session = UserSession.create(:login => users(:ben).login, :password => "invalud-password")
+        assert_equal ["Password is not valid"], session.errors.full_messages
+      end
+      
+      def test_generalize_credentials_error_messages_set_to_true
+        UserSession.generalize_credentials_error_messages true
+        assert UserSession.generalize_credentials_error_messages
+        session = UserSession.create(:login => users(:ben).login, :password => "invalud-password")
+        assert_equal ["Login/Password combination is not valid"], session.errors.full_messages
+      end
+
+      def test_generalize_credentials_error_messages_set_to_string
+        UserSession.generalize_credentials_error_messages= "Custom Error Message"
+        assert UserSession.generalize_credentials_error_messages
+        session = UserSession.create(:login => users(:ben).login, :password => "invalud-password")
+        assert_equal ["Custom Error Message"], session.errors.full_messages
+      end
+
+      
       def test_login_field
         UserSession.configured_password_methods = false
         UserSession.login_field = :saweet
@@ -81,4 +103,4 @@ module SessionTest
       end
     end
   end
-end
+end

data/test/session_test/session_test.rb

@@ -18,41 +18,41 @@ module SessionTest
         set_session_for(ben)
         assert session = UserSession.find
         assert_equal ben, session.record
-        assert_equal ben.persistence_token, @controller.session["user_credentials"]
+        assert_equal ben.persistence_token, controller.session["user_credentials"]
       end
       
       def test_persist_persist_by_session_with_token_only
         ben = users(:ben)
         set_session_for(ben)
-        @controller.session["user_credentials_id"] = nil
+        controller.session["user_credentials_id"] = nil
         assert session = UserSession.find
         assert_equal ben, session.record
-        assert_equal ben.persistence_token, @controller.session["user_credentials"]
+        assert_equal ben.persistence_token, controller.session["user_credentials"]
       end
     
       def test_after_save_update_session
         ben = users(:ben)
         session = UserSession.new(ben)
-        assert @controller.session["user_credentials"].blank?
+        assert controller.session["user_credentials"].blank?
         assert session.save
-        assert_equal ben.persistence_token, @controller.session["user_credentials"]
+        assert_equal ben.persistence_token, controller.session["user_credentials"]
       end
     
       def test_after_destroy_update_session
         ben = users(:ben)
         set_session_for(ben)
-        assert_equal ben.persistence_token, @controller.session["user_credentials"]
+        assert_equal ben.persistence_token, controller.session["user_credentials"]
         assert session = UserSession.find
         assert session.destroy
-        assert @controller.session["user_credentials"].blank?
+        assert controller.session["user_credentials"].blank?
       end
     
       def test_after_persisting_update_session
         ben = users(:ben)
         set_cookie_for(ben)
-        assert @controller.session["user_credentials"].blank?
+        assert controller.session["user_credentials"].blank?
         assert UserSession.find
-        assert_equal ben.persistence_token, @controller.session["user_credentials"]
+        assert_equal ben.persistence_token, controller.session["user_credentials"]
       end
     end
   end

data/test/session_test/timeout_test.rb

@@ -25,7 +25,7 @@ module SessionTest
         assert session.stale?
         assert_equal ben, session.stale_record
         assert_nil session.record
-        assert_nil @controller.session["user_credentials_id"]
+        assert_nil controller.session["user_credentials_id"]
       
         set_session_for(ben)
       
@@ -38,6 +38,15 @@ module SessionTest
       
         UserSession.logout_on_timeout = false
       end
+      
+      def test_successful_login
+        UserSession.logout_on_timeout = true
+        ben = users(:ben)
+        assert UserSession.create(:login => ben.login, :password => "benrocks")
+        assert session = UserSession.find
+        assert_equal ben, session.record
+        UserSession.logout_on_timeout = false
+      end
     end
   end
 end