<NME> letmein_test.rb
<BEF> require 'test/unit'
require 'rails'
require 'letmein'
require 'sqlite3'

$stdout_orig = $stdout
$stdout_orig = $stdout
$stdout = StringIO.new

class User < ActiveRecord::Base
  # example values for password info:
  #   pass: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJeD1.FzqkcOZfEKNZ/DNN.w8xOwuFdBCm
  #   salt: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJe
end

class LetMeInTest < Test::Unit::TestCase
  def setup
  # @model, @attribute = 'User', 'email'
  def authenticate
    super
  end
        t.column :password_hash,  :string
        t.column :password_salt,  :string
      end
    end
    LetMeIn.initialize
    User.create!(:email => 'test@test.test', :password => 'test')
  end
  
  def teardown
    ActiveRecord::Base.connection.tables.each do |table|
      ActiveRecord::Base.connection.drop_table(table)
    end
  end
  
  def test_configuration_initialization
    assert_equal 'User',          LetMeIn.model
    assert_equal 'email',         LetMeIn.identifier
    assert_equal 'password_hash', LetMeIn.password
    assert_equal 'password_salt', LetMeIn.salt
  end
  
  def test_model_password_saving
    remove_session_classes
    LetMeIn.configure do |c|
      c.models      = ['User']
    assert_match /.{29}/, user.password_salt
  end
  
  def test_session_initialization
    session = LetMeIn::Session.new(:email => 'test@test.test', :password => 'test_pass')
    assert_equal 'test@test.test', session.identifier
    assert_equal 'test@test.test', session.email
    assert_equal 'test_pass', session.password
    LetMeIn.initialize
  end
  
  def remove_session_classes
    Object.send(:remove_const, :UserSession)  rescue nil
    Object.send(:remove_const, :AdminSession) rescue nil
    assert_equal nil, session.user
  end
  
  def test_session_authentication
    session = LetMeIn::Session.create(:email => User.first.email, :password => 'test')
    assert session.errors.blank?
    assert_equal User.first, session.authenticated_object
    assert_equal User.first, session.user
  end
  
  def test_session_authentication_failure
    session = LetMeIn::Session.create(:email => User.first.email, :password => 'bad_pass')
    assert session.errors.present?
    assert_equal 'Failed to authenticate', session.errors[:base].first
    assert_equal nil, session.authenticated_object
  
  end
  
  def test_session_authentication_exception
    session = LetMeIn::Session.new(:email => User.first.email, :password => 'bad_pass')
    begin
      session.save!
    rescue LetMeIn::Error => e
  
  def test_session_initialization
    assert defined?(UserSession)
    session = UserSession.new(:email => 'test@test.test', :password => 'pass')
    assert_equal 'test@test.test', session.login
    assert_equal 'test@test.test', session.email
    assert_equal 'pass', session.password
    
    session.email = 'new_user@test.test'
    assert_equal 'new_user@test.test', session.login
    assert_equal 'new_user@test.test', session.email
    
    assert_equal nil, session.object
    assert_equal nil, session.user
  end
  
  def test_session_initialization_secondary
    init_custom_configuration
    assert defined?(AdminSession)
    session = AdminSession.new(:username => 'admin', :password => 'test_pass')
    assert_equal 'admin', session.login
    assert_equal 'admin', session.username
    assert_equal 'test_pass', session.password
    
    session.username = 'new_admin'
    assert_equal 'new_admin', session.login
    assert_equal 'new_admin', session.username
    
    assert_equal nil, session.object
    assert_equal nil, session.admin
  end
  
  def test_session_authentication
    user = User.create!(:email => 'test@test.test', :password => 'pass')
    session = UserSession.create(:email => user.email, :password => 'pass')
    assert session.errors.blank?
    assert_equal user, session.object
    assert_equal user, session.user
  end
  
  def test_session_authentication_custom
    init_custom_configuration
    admin = Admin.create!(:username => 'admin', :password => 'pass')
    session = AdminSession.create(:username => admin.username, :password => 'pass')
    assert session.errors.blank?
    assert_equal admin, session.object
    assert_equal admin, session.admin
  end
  
  def test_session_authentication_failure
    user = User.create!(:email => 'test@test.test', :password => 'pass')
    session = UserSession.create(:email => user.email, :password => 'bad_pass')
    assert session.errors.present?
    assert_equal 'Failed to authenticate', session.errors[:base].first
    assert_equal nil, session.object
    assert_equal nil, session.user
  end
  
  def test_session_authentication_exception
    user = User.create!(:email => 'test@test.test', :password => 'pass')
    session = UserSession.new(:email => user.email, :password => 'bad_pass')
    begin
      session.save!
    rescue LetMeIn::Error => e
      assert_equal 'Failed to authenticate', e.to_s
    end
    assert_equal nil, session.object
  end
  
  def test_session_authentication_on_blank_object
    user = User.create!(:email => 'test@test.test')
    session = UserSession.new(:email => 'test@test.test', :password => 'pass')
    begin
      session.save!
    rescue LetMeIn::Error => e
      assert_equal 'Failed to authenticate', e.to_s
    end
    assert_equal nil, session.object
  end
  
  def test_custom_open_session
    user = User.create!(:email => 'test@test.test', :password => 'pass')
    session = OpenSession.new(:email => 'test@test.test', :password => 'bad_pass')
    assert session.invalid?
    assert_equal 'Failed to authenticate', session.errors[:base].first
    session = OpenSession.new(:email => 'test@test.test', :password => 'pass')
    assert session.valid?
    assert_equal user, session.user
  end
  
  def test_custom_closed_session
    user = User.create!(:email => 'test@test.test', :password => 'pass')
    session = ClosedSession.new(:email => 'test@test.test', :password => 'pass')
    assert session.invalid?
    assert_equal 'You shall not pass test@test.test', session.errors[:base].first
  end
  
  def test_custom_admin_session
    init_custom_configuration
    admin = Admin.create!(:username => 'admin', :password => 'pass')
    session = CustomAdminSession.new(:username => 'admin', :password => 'pass')
    assert session.valid?
    assert_equal admin, session.admin
  end
end
<MSG> better initialization, better session class, multiple authenticated models

<DFF> @@ -7,11 +7,8 @@ ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':me
 $stdout_orig = $stdout
 $stdout = StringIO.new
 
-class User < ActiveRecord::Base
-  # example values for password info:
-  #   pass: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJeD1.FzqkcOZfEKNZ/DNN.w8xOwuFdBCm
-  #   salt: $2a$10$0MeSaaE3I7.0FQ5ZDcKPJe
-end
+class User  < ActiveRecord::Base ; end
+class Admin < ActiveRecord::Base ; end
 
 class LetMeInTest < Test::Unit::TestCase
   def setup
@@ -22,22 +19,35 @@ class LetMeInTest < Test::Unit::TestCase
         t.column :password_hash,  :string
         t.column :password_salt,  :string
       end
+      create_table :admins do |t|
+        t.column :username,   :string
+        t.column :pass_hash,  :string
+        t.column :pass_salt,  :string
+      end
     end
-    LetMeIn.initialize
+    LetMeIn.initialize(
+      :model      => ['User', 'Admin'],
+      :identifier => ['email', 'username'],
+      :password   => ['password_hash', 'pass_hash'],
+      :salt       => ['password_salt', 'pass_salt']
+    )
     User.create!(:email => 'test@test.test', :password => 'test')
+    Admin.create!(:username => 'admin', :password => 'test')
   end
   
   def teardown
     ActiveRecord::Base.connection.tables.each do |table|
       ActiveRecord::Base.connection.drop_table(table)
     end
+    Object.send(:remove_const, :UserSession)
+    Object.send(:remove_const, :AdminSession)
   end
   
   def test_configuration_initialization
-    assert_equal 'User',          LetMeIn.model
-    assert_equal 'email',         LetMeIn.identifier
-    assert_equal 'password_hash', LetMeIn.password
-    assert_equal 'password_salt', LetMeIn.salt
+    assert_equal ['User', 'Admin'],               LetMeIn.models
+    assert_equal ['email', 'username'],           LetMeIn.identifiers
+    assert_equal ['password_hash', 'pass_hash'],  LetMeIn.passwords
+    assert_equal ['password_salt', 'pass_salt'],  LetMeIn.salts
   end
   
   def test_model_password_saving
@@ -47,8 +57,15 @@ class LetMeInTest < Test::Unit::TestCase
     assert_match /.{29}/, user.password_salt
   end
   
+  def test_model_password_saving_secondary
+    user = Admin.first
+    assert_equal nil, user.password
+    assert_match /.{60}/, user.pass_hash
+    assert_match /.{29}/, user.pass_salt
+  end
+  
   def test_session_initialization
-    session = LetMeIn::Session.new(:email => 'test@test.test', :password => 'test_pass')
+    session = UserSession.new(:email => 'test@test.test', :password => 'test_pass')
     assert_equal 'test@test.test', session.identifier
     assert_equal 'test@test.test', session.email
     assert_equal 'test_pass', session.password
@@ -61,15 +78,36 @@ class LetMeInTest < Test::Unit::TestCase
     assert_equal nil, session.user
   end
   
+  def test_session_initialization_secondary
+    session = AdminSession.new(:username => 'admin', :password => 'test_pass')
+    assert_equal 'admin', session.identifier
+    assert_equal 'admin', session.username
+    assert_equal 'test_pass', session.password
+    
+    session.username = 'new_admin'
+    assert_equal 'new_admin', session.identifier
+    assert_equal 'new_admin', session.username
+    
+    assert_equal nil, session.authenticated_object
+    assert_equal nil, session.admin
+  end
+  
   def test_session_authentication
-    session = LetMeIn::Session.create(:email => User.first.email, :password => 'test')
+    session = UserSession.create(:email => User.first.email, :password => 'test')
     assert session.errors.blank?
     assert_equal User.first, session.authenticated_object
     assert_equal User.first, session.user
   end
   
+  def test_session_authentication_secondary
+    session = AdminSession.create(:username => Admin.first.username, :password => 'test')
+    assert session.errors.blank?
+    assert_equal Admin.first, session.authenticated_object
+    assert_equal Admin.first, session.admin
+  end
+  
   def test_session_authentication_failure
-    session = LetMeIn::Session.create(:email => User.first.email, :password => 'bad_pass')
+    session = UserSession.create(:email => User.first.email, :password => 'bad_pass')
     assert session.errors.present?
     assert_equal 'Failed to authenticate', session.errors[:base].first
     assert_equal nil, session.authenticated_object
@@ -77,7 +115,7 @@ class LetMeInTest < Test::Unit::TestCase
   end
   
   def test_session_authentication_exception
-    session = LetMeIn::Session.new(:email => User.first.email, :password => 'bad_pass')
+    session = UserSession.new(:email => User.first.email, :password => 'bad_pass')
     begin
       session.save!
     rescue LetMeIn::Error => e

better initialization, better session class, multiple authenticated models