adva_user 0.0.1

data/vendor/gems/authentication/test_backup/abstract_unit.rb

@@ -0,0 +1,30 @@
+# NOTE: Inherited from acts_as_versioned
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__),
+  '..', '..', '..', '..', 'config', 'environment.rb'))
+require 'active_record/fixtures'
+
+config = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'database.yml')))
+ActiveRecord::Base.logger =
+  Logger.new(File.join(File.dirname(__FILE__), 'debug.log'))
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite3'])
+
+load(File.join(File.dirname(__FILE__), 'schema.rb'))
+
+Test::Unit::TestCase.fixture_path = File.join(File.dirname(__FILE__),'fixtures')
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+
+  require File.join(File.dirname(__FILE__), 'test_helper.rb')
+end

data/vendor/gems/authentication/test_backup/active_record_extension_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+# Test minor enhancements to ActiveRecord
+class ActiveRecordExtensionTest < Test::Unit::TestCase
+  def test_column_includes
+    assert ColumnTest.includes_all_columns?(:foo, :bar)
+    assert !ColumnTest.includes_all_columns?(:foo, :boo)
+  end
+end
+
+class ColumnTest < ActiveRecord::Base
+  # Fake the column names
+  def self.column_names
+    %w(id name foo bar baz)
+  end
+end

data/vendor/gems/authentication/test_backup/authentication_test.rb

@@ -0,0 +1,231 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+# Will test the various dispatch methods mixed into the user model to enable
+# use of the various authentication and token modules. The main goal of this
+# test case is not to test the actual authentication but the process of
+# dispatching the methods to the various classes that implement the actual
+# authentication.
+class AuthenticationTest < Test::Unit::TestCase
+  fixtures :users
+
+  def teardown
+    (RecordedUser.authentication_modules + RecordedUser.token_modules).each do |mod|
+      mod.cleanup
+    end
+  end
+
+  def test_create_user_without_token_or_password
+    assert_nothing_raised { User.create! :first_name => 'John', :last_name => 'Doe' }
+  end
+
+  def test_authentication_first_success
+    first = RecordedUser.authentication_modules.first
+    first.send_back :authenticate, true
+
+    jack_with_test_password
+    assert @jack.authenticate('test')
+
+    jack_test_auth_message first
+  end
+
+  def test_authentication_first_fail_later_success
+    first = RecordedUser.authentication_modules.first
+    first.send_back :authenticate, false
+    last = RecordedUser.authentication_modules.last
+    last.send_back :authenticate, true
+
+    jack_with_test_password
+    assert @jack.authenticate('test')
+
+    jack_test_auth_message first, last
+  end
+
+  def test_authentication_no_success
+    first = RecordedUser.authentication_modules.first
+    first.send_back :authenticate, false
+    last = RecordedUser.authentication_modules.last
+    last.send_back :authenticate, false
+
+    jack_with_test_password
+    assert !@jack.authenticate('test')
+
+    jack_test_auth_message first, last
+  end
+
+  def test_authentication_with_token
+    first = RecordedUser.token_modules.first
+    first.send_back :authenticate, true
+
+    tok = jack_token
+    assert @jack.authenticate(tok)
+
+    jack_test_token_message tok, first
+  end
+
+  def test_authentication_with_token_first_fail_later_success
+    first = RecordedUser.token_modules.first
+    first.send_back :authenticate, false
+    last = RecordedUser.token_modules.last
+    last.send_back :authenticate, true
+
+    tok = jack_token
+    assert @jack.authenticate(tok)
+
+    jack_test_token_message tok, first, last
+  end
+
+  def test_authentication_with_token_no_success
+    first = RecordedUser.token_modules.first
+    first.send_back :authenticate, false
+    last = RecordedUser.token_modules.last
+    last.send_back :authenticate, false
+
+    tok = jack_token
+    assert_nil tok
+    assert !@jack.authenticate(tok)
+
+    jack_test_token_message tok, first, last
+  end
+
+  def test_assign_token_first_success
+    first = RecordedUser.token_modules.first
+    first.send_back :assign_token, 'test_token'
+
+    tok = jack_token
+    assert_equal 'test_token', tok
+    jack_test_assign_tok_message first
+  end
+
+  def test_assign_token_first_fail_later_success
+    first = RecordedUser.token_modules.first
+    first.send_back :assign_token, nil
+    last = RecordedUser.token_modules.last
+    last.send_back :assign_token, 'last_token'
+
+    tok = jack_token
+    assert_equal 'last_token', tok
+    jack_test_assign_tok_message first, last
+  end
+
+  def test_assign_token_no_success
+    first = RecordedUser.token_modules.first
+    first.send_back :assign_token, nil
+    last = RecordedUser.token_modules.last
+    last.send_back :assign_token, nil
+
+    tok = jack_token
+    assert_nil tok
+    jack_test_assign_tok_message first, last
+  end
+
+  def test_assign_password
+    first = RecordedUser.authentication_modules.first
+    last = RecordedUser.authentication_modules.last
+
+    jane = RecordedUser.new :first_name => 'Jane', :last_name => 'Doe'
+    jane.password = 'testing'
+    jane.save!
+    jane.reload
+
+    [first, last].each do |auth|
+      message = auth.last_message
+
+      assert_equal :assign_password, message.first
+      assert_equal jane, message[1]
+      assert_equal 'testing', message[2]
+    end
+  end
+
+  def test_blank_password_does_not_overwrite
+    jenny = User.new :first_name => 'Jenny'
+    jenny.password = 'test'
+    jenny.save!
+    jenny.reload
+    jenny.password = ""
+    jenny.save!
+    jenny.reload
+    assert jenny.authenticate('test')
+  end
+
+  private
+
+  def jack_with_test_password
+    @jack = RecordedUser.new :first_name => 'Jack'
+    @jack.password = 'test'
+    @jack.save!
+    @jack.reload
+  end
+
+  def jack_token
+    @jack = RecordedUser.new :first_name => 'Jack'
+    tok = @jack.assign_token 'test'
+    @jack.save!
+    @jack.reload
+    tok
+  end
+
+  def jack_test_auth_message(*auths)
+    auths.each do |auth|
+      message = auth.last_message
+      assert_equal :authenticate, message.first
+      assert_equal @jack, message[1]
+      assert_equal 'test', message[2]
+    end
+  end
+
+  def jack_test_token_message(token, *toks)
+    toks.each do |tok|
+      message = tok.last_message
+      assert_equal :authenticate, message.first
+      assert_equal @jack, message[1]
+      assert_equal token, message[2]
+    end
+  end
+
+  def jack_test_assign_tok_message(*toks)
+    toks.each do |tok|
+      message = tok.last_message
+      assert_equal :assign_token, message.first
+      assert_equal @jack, message[1]
+      assert_equal 3.days.from_now.to_date, message[3].to_date
+    end
+  end
+end
+
+# Utility class that will record everything passed in so we can test the
+# receipt of the various messages with the various arguments. This class is
+# working both as a cryptor and tokener.
+class AuthRecorder
+  def initialize(*args)
+    @record = []
+    @returns = {}
+  end
+  def method_missing(meth, *args)
+    @record << [meth, *args]
+    @returns[meth]
+  end
+  def send_back(meth, ret)
+    @returns[meth] = ret
+  end
+  def last_message
+    @record.last
+  end
+  def cleanup
+    @record = []
+    @returns = {}
+  end
+  def assign_token(*args)
+    method_missing :assign_token, *args
+  end
+  def assign_password(*args)
+    method_missing :assign_password, *args
+  end
+end
+
+# Class configured to use a few AuthRecorders
+class RecordedUser < User
+  acts_as_authenticated_user \
+    :authenticate_with => ['AuthRecorder']*2,
+    :token_with => ['AuthRecorder']*2
+end

data/vendor/gems/authentication/test_backup/database.yml

@@ -0,0 +1,12 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: authentication_plugin_test.sqlite.db
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: authentication_plugin_test.sqlite3.db
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: rails
+  :password:
+  :database: authentication_plugin_test

data/vendor/gems/authentication/test_backup/fixtures/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  acts_as_authenticated_user
+end

data/vendor/gems/authentication/test_backup/fixtures/users.yml

@@ -0,0 +1,3 @@
+joe:
+  id: 1
+  name: Joe

data/vendor/gems/authentication/test_backup/options_test.rb

@@ -0,0 +1,100 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+# The goal of this test case is to ensure that the options processing of the
+# macro function are being handled properly.
+class OptionsTest < Test::Unit::TestCase
+
+  def test_no_args
+    auth_mods = UserNoArgs.authentication_modules
+    token_mods = UserNoArgs.token_modules
+
+    assert_equal 1, auth_mods.size
+    assert_equal 2, token_mods.size
+
+    assert_instance_of Authentication::SaltedHash, auth_mods.first
+    assert_instance_of Authentication::RememberMe, token_mods.first
+    assert_instance_of Authentication::SingleToken, token_mods.last
+  end
+
+  def test_with_auth_mod
+    auth_mods = UserWithAuthMod.authentication_modules
+    assert_equal 1, auth_mods.size
+    assert_instance_of BasicAuthMod, auth_mods.first
+  end
+
+  def test_with_token_mod
+    token_mods = UserWithTokenMod.token_modules
+    assert_equal 1, token_mods.size
+    assert_instance_of BasicTokenMod, token_mods.first
+  end
+
+  def test_multiple_mods
+    auth_mods = UserWithMultipleMods.authentication_modules
+    assert_equal 2, auth_mods.size
+    assert_instance_of BasicAuthMod, auth_mods.first
+    assert_instance_of Authentication::SaltedHash, auth_mods.last
+  end
+
+  def test_mods_with_args
+    auth_mods = UserWithArgMod.authentication_modules
+    assert_equal 1, auth_mods.size
+    assert_instance_of ArgAuthMod, auth_mods.first
+    assert_equal 1, auth_mods.first.args.size
+    assert_equal 'test', auth_mods.first.args.first[:server]
+  end
+
+  def test_multiple_mods_with_args
+    auth_mods = UserWithMultipleArgs.authentication_modules
+    assert_equal 2, auth_mods.size
+    assert_instance_of ArgAuthMod, auth_mods.first
+    assert_instance_of AnotherArgAuthMod, auth_mods.last
+    assert_equal 1, auth_mods.first.args.size
+    assert_equal 'test', auth_mods.first.args.first[:server]
+    assert_equal 'testing', auth_mods.last.args.first[:server]
+  end
+end
+
+class UserNoArgs < ActiveRecord::Base
+  acts_as_authenticated_user
+end
+
+class BasicAuthMod
+end
+
+class UserWithAuthMod < ActiveRecord::Base
+  acts_as_authenticated_user :authenticate_with => 'BasicAuthMod'
+end
+
+class BasicTokenMod
+end
+
+class UserWithTokenMod < ActiveRecord::Base
+  acts_as_authenticated_user :token_with => 'BasicTokenMod'
+end
+
+class UserWithMultipleMods < ActiveRecord::Base
+  acts_as_authenticated_user :authenticate_with =>
+    ['BasicAuthMod', 'Authentication::SaltedHash']
+end
+
+class ArgAuthMod
+  def initialize(*args)
+    self.args = args
+  end
+  attr_accessor :args
+end
+class AnotherArgAuthMod < ArgAuthMod
+end
+
+class UserWithArgMod < ActiveRecord::Base
+  acts_as_authenticated_user :authenticate_with =>
+    {'ArgAuthMod' => {:server => 'test'}}
+end
+
+class UserWithMultipleArgs < ActiveRecord::Base
+  acts_as_authenticated_user :authenticate_with => [
+    {'ArgAuthMod' => {:server => 'test'}},
+    {'AnotherArgAuthMod' => {:server => 'testing'}}
+  ]
+end

data/vendor/gems/authentication/test_backup/remember_me_test.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+# Tests RememberMe to see if it can allocate remember me tokens and
+# validate those tokens correctly. This is very similar to single
+# token except that it stores in a different field and will not care
+# about expiration
+class RememberMe < Test::Unit::TestCase
+  include Authentication::HashHelper
+  fixtures :users
+
+  def setup
+    @tokener = Authentication::RememberMe.new
+
+    @joe = users(:joe)
+    @key = @tokener.assign_token @joe, 'remember me'
+    @joe.save!
+    @joe.reload
+  end
+
+  def test_assign_remember_me
+    assert_equal hash_string(@key), @joe.remember_me
+  end
+
+  def test_authenticate
+    assert @tokener.authenticate(@joe, @key)
+    assert !@tokener.authenticate(@joe, "invalid key")
+  end
+
+  def test_expiration_does_not_matter
+    expired_key = @tokener.assign_token @joe, 'remember me', 1.day.ago
+    @joe.save!
+    @joe.reload
+
+    assert @tokener.authenticate(@joe, expired_key)
+  end
+
+  def test_non_remember_me
+    assert_nil @tokener.assign_token(@joe, 'invalid', 3.days.from_now)
+  end
+end

data/vendor/gems/authentication/test_backup/salted_hash_test.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), 'abstract_unit')
+
+# Tests SaltedHash class to ensure it can authenticate and assign
+# passwords correctly
+class SaltedHashTest < Test::Unit::TestCase
+  fixtures :users
+
+  def setup
+    @password = "foobazzle"
+    @crypter = Authentication::SaltedHash.new
+
+    @joe = users(:joe)
+    @crypter.assign_password @joe, @password
+    @joe.save!
+    @joe.reload
+  end
+
+  # We are basically just going to test that it gets assigned. We can
+  # really only test if it was assigned the right value when we test
+  # authenticate
+  def test_assign_password
+    assert_not_nil @joe.password_salt
+    assert_not_nil @joe.password_hash
+  end
+
+  def test_authenticate
+    assert @crypter.authenticate(@joe, @password)
+    assert !@crypter.authenticate(@joe, "false password")
+  end
+
+  def test_model_validation
+    class << User; alias_method :backup_column_names, :column_names end
+    def User.column_names; %w(id name password) end
+    assert !@crypter.authenticate(@joe, @password)
+    class << User; alias_method :column_names, :backup_column_names end
+  end
+end