## user.rb

require 'digest/sha1'

class User < ActiveRecord::Base

  attr_accessor :password
  attr_accessor :password_confirmation
  message_order = "new DESC, created_on ASC"
  has_many :messages, :order => message_order

  validates_presence_of :email_address, :screen_name, :real_name
  validates_uniqueness_of :email_address
  validates_length_of :screen_name, :maximum => 20
  validates_length_of :real_name, :maximum => 50
  validates_length_of :password, :within => 5..25
  validates_confirmation_of :password, :message => "did not match the confirmation"
  validates_format_of :email_address, :with => /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/


  def after_validation_on_create
    return false unless self.password
    create_salt
    self.hashed_password = User.encrypt_password(self.password, self.salt)
    #self.password, self.password_confirmation = nil
  end

  def self.login(email_address, password)
    user = self.find_by_email_address(email_address)
    unless user && (User.encrypt_password(password, user.salt) == user.hashed_password)
      user = nil
    end
    user
  end

  def mailbox
    Mailbox.new(self)
  end

  private
  def create_salt
    self.salt = self.object_id.to_s   rand.to_s
  end

  def self.encrypt_password(password, salt)
    string_to_hash = password   "blync"   salt
    Digest::SHA1.hexdigest(string_to_hash)
  end

end

## user_test.rb

require File.dirname(__FILE__)   '/../test_helper'

class UserTest < Test::Unit::TestCase
  fixtures :users

  def setup
    @blank_user = User.new
  end

  def test_blank_user
    user = @blank_user
    assert !user.valid?
    assert user.errors.invalid?(:email_address)
    assert user.errors.invalid?(:real_name)
    assert user.errors.invalid?(:password)
  end

  def test_good_user
    user = create_user
    assert user.valid?
  end

  def test_password_confirmation
   user = create_user(:password_confirmation => "")
   assert !user.valid?
   assert user.errors.on(:password)
  end

  def test_password_length
    user = create_user
    user.password = "hi"
    assert !user.valid?
    assert user.errors.on(:password)
    user.password = "abababababababababababababababababababab"
    assert !user.valid?
    assert user.errors.on(:password)
  end

  def test_email_uniqueness
  #A user with email address: 'joe@me.com' is already in a fixture
    user = create_user(:email_address => 'joe@me.com')
    assert !user.save
    assert user.errors.on(:email_address)
  end

  def test_field_lengths
    user = create_user(:screen_name => 'asdfjkllmnsdfgfgsdfdgsdgs')
    assert !user.valid?
    assert user.errors.on(:screen_name)
    user = create_user(:real_name => 'asldfjklasjdfklajsdklfjasklasldfjklasjdfklajsdklfjasklasldfjklasjdfklajsdklfjaskl')
    assert !user.valid?
    assert user.errors.on(:real_name)
  end

  def test_email_address_format
    bad = ['joe@', '@', 'poopy', 'test@joe', '@joe.com'  ]
    good = [ 'kimberly@aol.com', 'joe@black.net', 'jason@testing.org', 'test@suck.us' ]

    assert_user_array(bad, :field => 'email_address', :assertion => 'reverse')
    assert_user_array(good, :field => 'email_address')
  end

  def assert_hashing
    user = create_user
    user.save!
    assert_equal User.encrypt_password("password", user.salt), user.hashed_password
  end

  protected

  def assert_user_array(array, options = {})
    field = options[:field] if options[:field]
    assertion = options[:assertion] if options[:assertion]

    array.each do |item|
      user = create_user(field.to_sym => item)
      case assertion
        when 'reverse'
          assert !user.valid?
          assert user.errors.on(field.to_sym)
        else
          assert user.valid?
      end
    end
  end

  def create_user(options = {})
    User.new({ :email_address => 'joe@joe.com',
                          :screen_name => "joeizzle",
                          :real_name => "Joe Black",
                          :password => "password",
                          :password_confirmation => "password" }.merge(options))
  end
end