authlogic 1.4.3 → 2.0.0

data/test/orm_adapters_tests/active_record_adapter_tests/acts_as_authentic_tests/session_maintenance_test.rb

@@ -1,62 +0,0 @@
-require File.dirname(__FILE__) + '/../../../test_helper.rb'
-
-module ORMAdaptersTests
-  module ActiveRecordAdapterTests
-    module ActsAsAuthenticTests
-      class SessionMaintenanceTest < ActiveSupport::TestCase
-        def test_login_after_create
-          assert User.create(:login => "awesome", :password => "saweet", :password_confirmation => "saweet", :email => "awesome@awesome.com")
-          assert UserSession.find
-        end
-
-        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"]
-          ben.password = "newpass"
-          ben.password_confirmation = "newpass"
-          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
-        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"]
-          ben.first_name = "Ben"
-          ben.save
-          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"]
-          zack = users(:zack)
-          zack.password = "newpass"
-          zack.password_confirmation = "newpass"
-          zack.save
-          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
-          ben = users(:ben)
-          assert !UserSession.find
-          ben.password = "newpass"
-          ben.password_confirmation = "newpass"
-          ben.save
-          assert UserSession.find
-          assert_equal ben, UserSession.find.record
-        end
-      end
-    end
-  end
-end

data/test/orm_adapters_tests/active_record_adapter_tests/acts_as_authentic_tests/single_access_test.rb

@@ -1,41 +0,0 @@
-require File.dirname(__FILE__) + '/../../../test_helper.rb'
-
-module ORMAdaptersTests
-  module ActiveRecordAdapterTests
-    module ActsAsAuthenticTests
-      class SingleAccessTest < ActiveSupport::TestCase
-        def test_before_validation
-          user = User.new
-          assert_equal nil, user.single_access_token
-          assert !user.valid?
-          assert user.single_access_token
-        end
-        
-        def test_change_with_password
-          ben = users(:ben)
-          old_single_access_token = ben.single_access_token
-          
-          User.acts_as_authentic(:change_single_access_token_with_password => true)
-          ben.password = "new_pass"
-          assert_not_equal old_single_access_token, ben.single_access_token
-          
-          ben.reload
-          User.acts_as_authentic(:change_single_access_token_with_password => false)
-          ben.password = "new_pass"
-          assert_equal old_single_access_token, ben.single_access_token
-        end
-        
-        def test_reset_single_access_token
-          ben = users(:ben)
-          old_single_access_token = ben.single_access_token
-          ben.reset_single_access_token
-          assert_not_equal old_single_access_token, ben.single_access_token
-          ben.reload
-          assert_equal old_single_access_token, ben.single_access_token
-          ben.reset_single_access_token!
-          assert_not_equal old_single_access_token, ben.single_access_token
-        end
-      end
-    end
-  end
-end

data/test/orm_adapters_tests/active_record_adapter_tests/authenticates_many_test.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper.rb'
-
-module ORMAdaptersTests
-  module ActiveRecordAdapterTests
-    class AuthenticatesManyTest < ActiveSupport::TestCase
-      def test_authenticates_many_new
-        binary_logic = companies(:binary_logic)
-        user_session = binary_logic.user_sessions.new
-        assert_equal({:find_options => {:conditions => "\"users\".company_id = #{binary_logic.id}"}, :id => nil}, user_session.scope)
-    
-        employee_session = binary_logic.employee_sessions.new
-        assert_equal({:find_options => {:conditions => "\"employees\".company_id = #{binary_logic.id}"}, :id => nil}, employee_session.scope)
-      end
-  
-      def test_authenticates_many_create_and_find
-        binary_logic = companies(:binary_logic)
-        logic_over_data = companies(:logic_over_data)
-        ben = users(:ben)
-        zack = users(:zack)
-    
-        assert !binary_logic.user_sessions.find
-        assert !logic_over_data.user_sessions.find
-        assert logic_over_data.user_sessions.create(zack)
-        assert !binary_logic.user_sessions.find
-        assert logic_over_data.user_sessions.find
-        assert binary_logic.user_sessions.create(ben)
-        assert binary_logic.user_sessions.find
-        assert !logic_over_data.user_sessions.find
-      end
-    end
-  end
-end

data/test/session_tests/active_record_trickery_test.rb

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module SessionTests
-  class ActiveRecordTrickeryTest < ActiveSupport::TestCase
-    def test_human_attribute_name
-      assert_equal "Some attribute", UserSession.human_attribute_name("some_attribute")
-    end
-  
-    def test_new_record
-      session = UserSession.new
-      assert session.new_record?
-    end
-  end
-end

data/test/session_tests/authenticates_many_association_test.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module SessionTests
-  class AuthenticatesManyAssociationTest < ActiveSupport::TestCase
-    def test_initialize
-      assoc = Authlogic::Session::AuthenticatesManyAssociation.new(UserSession, {:conditions => ["1 = ?", 1]}, :some_id)
-      assert_equal UserSession, assoc.klass
-      assert_equal({:conditions => ["1 = ?", 1]}, assoc.find_options)
-      assert_equal :some_id, assoc.id
-    end
-    
-    def test_new
-      ben = users(:ben)
-      assoc = Authlogic::Session::AuthenticatesManyAssociation.new(UserSession, {:conditions => ["1 = ?", 1]}, :some_id)
-      session = assoc.new(ben)
-      assert_equal ben, session.unauthorized_record
-      assert_equal({:find_options => {:conditions => ["1 = ?", 1]}, :id => :some_id}, session.scope)
-    end
-    
-    def test_build
-      binary_logic = companies(:binary_logic)
-      ben = users(:ben)
-      session = binary_logic.user_sessions.build(ben)
-      assert_equal ben, session.unauthorized_record
-      assert_equal({:find_options => {:conditions => "\"users\".company_id = #{binary_logic.id}"}, :id => nil}, session.scope)
-    end
-  end
-end

data/test/session_tests/base_test.rb

@@ -1,307 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper.rb'
-
-module SessionTests
-  class BaseTest < ActiveSupport::TestCase
-    def test_activated
-      assert UserSession.activated?
-      Authlogic::Session::Base.controller = nil
-      assert !UserSession.activated?
-    end
-    
-    def test_controller
-      Authlogic::Session::Base.controller = nil
-      assert_nil Authlogic::Session::Base.controller
-      thread1 = Thread.new do
-        controller = MockController.new
-        Authlogic::Session::Base.controller = controller
-        assert_equal controller, Authlogic::Session::Base.controller
-      end
-      thread1.join
-
-      assert_nil Authlogic::Session::Base.controller
-      
-      thread2 = Thread.new do
-        controller = MockController.new
-        Authlogic::Session::Base.controller = controller
-        assert_equal controller, Authlogic::Session::Base.controller
-      end
-      thread2.join
-      
-      assert_nil Authlogic::Session::Base.controller
-    end
-    
-    def test_create
-      ben = users(:ben)
-      assert !UserSession.create(:login => ben.login, :password => "badpw")
-      assert UserSession.create(:login => ben.login, :password => "benrocks")
-      assert_raise(Authlogic::Session::SessionInvalid) { UserSession.create!(:login => ben.login, :password => "badpw") }
-      assert UserSession.create!(:login => ben.login, :password => "benrocks")
-    end
-    
-    def test_find
-      ben = users(:ben)
-      assert !UserSession.find
-      http_basic_auth_for(ben) { assert UserSession.find }
-      set_cookie_for(ben)
-      assert UserSession.find
-      unset_cookie
-      set_session_for(ben)
-      session = UserSession.find
-      assert session
-    end
-    
-    def test_klass
-      assert_equal User, UserSession.klass
-    end
-    
-    def test_klass_name
-      assert_equal "User", UserSession.klass_name
-    end
-    
-    def test_record_method
-      ben = users(:ben)
-      set_session_for(ben)
-      session = UserSession.find
-      assert_equal ben, session.record
-      assert_equal ben, session.user
-    end
-    
-    def test_init
-      UserSession.controller = nil
-      assert_raise(Authlogic::Session::NotActivated) { UserSession.new }
-      UserSession.controller = @controller
-      
-      session = UserSession.new
-      assert session.respond_to?(:login)
-      assert session.respond_to?(:login=)
-      assert session.respond_to?(:password)
-      assert session.respond_to?(:password=)
-      assert session.respond_to?(:protected_password, true)
-      
-      session = UserSession.new(:my_id)
-      assert_equal :my_id, session.id
-      
-      session = UserSession.new({:login => "login", :password => "pass", :remember_me => true}, :my_id)
-      assert_equal "login", session.login
-      assert_nil session.password
-      assert_equal "pass", session.send(:protected_password)
-      assert_equal true, session.remember_me
-      assert_equal :my_id, session.id
-      
-      session = UserSession.new(users(:ben), true, :my_id)
-      assert_nil session.login
-      assert_nil session.password
-      assert_nil session.send(:protected_password)
-      assert session.remember_me
-      assert_equal :my_id, session.id
-      assert_equal users(:ben), session.unauthorized_record
-    end
-    
-    def test_credentials
-      session = UserSession.new
-      session.credentials = {:login => "login", :password => "pass", :remember_me => true}
-      assert_equal "login", session.login
-      assert_nil session.password
-      assert_equal "pass", session.send(:protected_password)
-      assert_equal true, session.remember_me
-      assert_equal({:password => "<Protected>", :login => "login"}, session.credentials)
-    end
-  
-    def test_destroy
-      ben = users(:ben)
-      session = UserSession.new
-      assert !session.valid?
-      assert !session.errors.empty?
-      assert session.destroy
-      assert session.errors.empty?
-      session.unauthorized_record = ben
-      assert session.save
-      assert session.record
-      assert session.destroy
-      assert !session.record
-    end
-    
-    def test_errors
-      session = UserSession.new
-      assert session.errors.is_a?(Authlogic::Session::Errors)
-    end
-    
-    def test_find_record
-      # tested thoroughly in test_find
-    end
-    
-    def test_id
-      ben = users(:ben)
-      session = UserSession.new(ben, :my_id)
-      assert_equal :my_id, session.id
-      assert_equal "my_id_user_credentials", session.cookie_key
-      assert_equal "my_id_user_credentials", session.session_key
-    end
-    
-    def test_inspect
-      session = UserSession.new
-      assert_equal "#<UserSession #{{:login=>nil, :password=>"<protected>"}.inspect}>", session.inspect
-      session.login = "login"
-      session.password = "pass"
-      assert "#<UserSession #{{:login=>"login", :password=>"<protected>"}.inspect}>" == session.inspect
-    end
-    
-    def test_new_session
-      session = UserSession.new
-      assert session.new_session?
-      
-      set_session_for(users(:ben))
-      session = UserSession.find
-      assert !session.new_session?
-    end
-    
-    def test_remember_me
-      session = UserSession.new
-      assert_nil session.remember_me
-      assert !session.remember_me?
-      
-      session.remember_me = false
-      assert_equal false, session.remember_me
-      assert !session.remember_me?
-      
-      session.remember_me = true
-      assert_equal true, session.remember_me
-      assert session.remember_me?
-      
-      session.remember_me = nil
-      assert_nil session.remember_me
-      assert !session.remember_me?
-      
-      session.remember_me = "1"
-      assert_equal "1", session.remember_me
-      assert session.remember_me?
-      
-      session.remember_me = "true"
-      assert_equal "true", session.remember_me
-      assert session.remember_me?
-    end
-    
-    def test_remember_me_until
-      session = UserSession.new
-      assert_nil session.remember_me_until
-      
-      session.remember_me = true
-      assert 3.months.from_now <= session.remember_me_until
-    end
-    
-    def test_save_with_nothing
-      session = UserSession.new
-      assert !session.save
-      assert session.new_session?
-    end
-    
-    def test_save_with_credentials
-      ben = users(:ben)
-      session = UserSession.new(:login => ben.login, :password => "benrocks")
-      assert session.save
-      assert !session.new_session?
-      assert_equal 1, session.record.login_count
-      assert Time.now >= session.record.current_login_at
-      assert_equal "1.1.1.1", session.record.current_login_ip
-    end
-    
-    def test_save_with_record
-      ben = users(:ben)
-      session = UserSession.new(ben)
-      assert session.save
-      assert !session.new_session?
-      assert_equal 1, session.record.login_count
-      assert Time.now >= session.record.current_login_at
-      assert_equal "1.1.1.1", session.record.current_login_ip
-    end
-    
-    def test_save_with_block
-      ben = users(:ben)
-      session = UserSession.new(:login => ben.login, :password => "benrocks")
-      block_result = session.save do |result|
-        assert result
-      end
-      assert_equal session, block_result
-      assert !session.new_session?
-      assert_equal 1, session.record.login_count
-      assert Time.now >= session.record.current_login_at
-      assert_equal "1.1.1.1", session.record.current_login_ip
-    end
-    
-    def test_save_with_bang
-      session = UserSession.new
-      assert_raise(Authlogic::Session::SessionInvalid) { session.save! }
-      
-      session.unauthorized_record = users(:ben)
-      assert session.save!
-    end
-    
-    def test_unauthorized_record
-      session = UserSession.new
-      ben = users(:ben)
-      session.unauthorized_record = ben
-      assert_equal ben, session.unauthorized_record
-      assert_equal :unauthorized_record, session.authenticating_with
-    end
-    
-    def test_valid
-      session = UserSession.new
-      assert !session.valid?
-      assert_nil session.record
-      assert session.errors.count > 0
-      
-      ben = users(:ben)
-      session.unauthorized_record = ben
-      assert session.valid?
-      assert_equal ben, session.record
-      assert session.errors.empty?
-    end
-    
-    def test_valid_record
-      session = UserSession.new
-      ben = users(:ben)
-      session.send(:record=, ben)
-      assert session.send(:valid_record?)
-      assert session.errors.empty?
-      
-      ben.update_attribute(:active, false)
-      assert !session.send(:valid_record?) 
-      assert session.errors.on_base.size > 0
-      
-      ben.active = true
-      ben.approved = false
-      ben.save
-      assert !session.send(:valid_record?) 
-      assert session.errors.on_base.size > 0
-      
-      ben.approved = true
-      ben.confirmed = false
-      ben.save
-      assert !session.send(:valid_record?)
-      assert session.errors.on_base.size > 0
-      
-      ben.approved = false
-      ben.confirmed = false
-      ben.active = false
-      
-      UserSession.disable_magic_states = true
-      session = UserSession.new
-      session.send(:record=, ben)
-      assert session.send(:valid_record?)
-    end
-    
-    def test_valid_http_auth
-      ben = users(:ben)
-      session = UserSession.new
-      
-      http_basic_auth_for { assert !session.valid_http_auth? }
-      
-      http_basic_auth_for(ben) do
-        assert session.valid_http_auth?
-        assert_equal ben, session.record
-        assert_equal ben.login, session.login
-        assert_equal "benrocks", session.send(:protected_password)
-      end
-    end
-  end
-end