functional
functional/account_controller_test.rb
functional/admin_controller_test.rb
functional/ads_controller_test.rb
functional/main_controller_test.rb
test_helper.rb
unit
unit/ad_test.rb
unit/author_test.rb
unit/category_test.rb
unit/mailman_test.rb
unit/parent_category_test.rb
unit/user_test.rb

-

/functional/account_controller_test.rb

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

require 'account_controller'

class AccountController; def rescue_action(e) raise e end; end

class AccountControllerTest < Test::Unit::TestCase

  include AuthenticatedTestHelper

  fixtures :users

  def setup

    @controller  AccountController.new

    @request  ActionController::TestRequest.new

    @response  ActionController::TestResponse.new

  end

  def test_should_login_and_redirect

    post :login, :email > 'quentin@example.com', :password > 'test'

    assert session[:user]

    assert_response :redirect

  end

  def test_should_fail_login_and_not_redirect

    post :login, :example > 'quentin@example', :password > 'bad password'

    assert_nil session[:user]

    assert_response :success

  end

  def test_should_allow_signup

    assert_difference User, :count do

      create_user

      assert_response :redirect

    end

  end

  def test_should_require_password_on_signup

    assert_no_difference User, :count do

      create_user(:password > nil)

      assert assigns(:user).errors.on(:password)

      assert_response :success

    end

  end

  def test_should_require_password_confirmation_on_signup

    assert_no_difference User, :count do

      create_user(:password_confirmation > nil)

      assert assigns(:user).errors.on(:password_confirmation)

      assert_response :success

    end

  end

  def test_should_require_email_on_signup

    assert_no_difference User, :count do

      create_user(:email > nil)

      assert assigns(:user).errors.on(:email)

      assert_response :success

    end

  end

  def test_should_logout

    login_as :quentin

    get :logout

    assert_nil session[:user]

    assert_response :redirect

  end

  def test_should_remember_me

    post :login, :email > 'quentin@example.com', :password > 'test', :remember_me > "1"

    assert_not_nil @response.cookies["auth_token"]

  end

  def test_should_not_remember_me

    post :login, :email > 'quentin@example.com', :password > 'test', :remember_me > "0"

    assert_nil @response.cookies["auth_token"]

  end

  def test_should_delete_token_on_logout

    login_as :quentin

    get :logout

    assert_equal @response.cookies["auth_token"], []

  end

  def test_should_login_with_cookie

    users(:quentin).remember_me

    @request.cookies["auth_token"]  cookie_for(:quentin)

    get :index

    assert @controller.send(:logged_in?)

  end

  def test_should_fail_expired_cookie_login

    users(:quentin).remember_me

    users(:quentin).update_attribute :remember_token_expires_at, 5.minutes.ago

    @request.cookies["auth_token"]  cookie_for(:quentin)

    get :index

    assert !@controller.send(:logged_in?)

  end

  def test_should_fail_cookie_login

    users(:quentin).remember_me

    @request.cookies["auth_token"]  auth_token('invalid_auth_token')

    get :index

    assert !@controller.send(:logged_in?)

  end

  protected

    def create_user(options  {})

      post :signup, :user > { :email > 'quire@example.com',

        :password > 'quire', :password_confirmation > 'quire' }.merge(options)

    end

    def auth_token(token)

      CGI::Cookie.new('name' > 'auth_token', 'value' > token)

    end

    def cookie_for(user)

      auth_token users(user).remember_token

    end

end

-

/functional/admin_controller_test.rb

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

class AdminControllerTest < ActionController::TestCase

  def test_truth

    assert true

  end

end

-

/functional/ads_controller_test.rb

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

class AdsControllerTest < ActionController::TestCase

  def test_ad_post_and_email_sent

    get :new, {:category > 1, :title > 'test', :ad > 'test ad'}

    assert_response :success

  end

  def test_url_click_activates_post

    assert true

  end

end

-

/functional/main_controller_test.rb

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

class MainControllerTest < ActionController::TestCase

  def test_truth

    assert true

  end

end

-

/test_helper.rb

ENV["RAILS_ENV"]  "test"

require File.expand_path(File.dirname(__FILE__) + "/../config/environment")

require 'test_help'

class Test::Unit::TestCase

  self.use_transactional_fixtures  true

  self.use_instantiated_fixtures  false

  fixtures :all

end

-

/unit/ad_test.rb

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

class ClassifiedAdTest < ActiveSupport::TestCase

  def test_ad_creation

    ad  Ad.create(:title > ads(:test_one).title)

    assert ad.valid?

    assert_equal(ads(:test_one).title, ad.title)

    assert_equal(false, ad.active)

    assert !ad.activation_hash.nil?

  end

  def test_email_generation_is_working

    ad  Ad.create(:title > ads(:test_one).title)

    assert ad.valid?

    assert_match(/^\d{18}@(chuckslist.com)$/i, ad.email)

  end

  def test_no_clash_in_generated_email_address

    for count in (1..10000)

      ad1  Ad.create(:title > 'Ad1')

      ad2  Ad.create(:title > 'Ad2')

      assert_not_equal(ad1.email, ad2.email)

    end

  end

  def test_created_ads

  end

end

-

/unit/author_test.rb

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

class AuthorTest < ActiveSupport::TestCase

  def test_truth

    assert true

  end

end

-

/unit/category_test.rb

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

class CategoryTest < ActiveSupport::TestCase

  def test_truth

    assert true

  end

end

-

/unit/mailman_test.rb

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

class MailmanTest < ActionMailer::TestCase

  tests Mailman

  def test_email_fixture_is_working

    email_text  read_fixture("test_mail_001").join

    assert_match(/jalopy/i, email_text)

  end

  def test_receive_email_is_working

    email_text  read_fixture("test_mail_001").join

    response  Mailman.receive(email_text)

    assert_not_equal("200806159145300001@chuckslist.com", response.to[0])

    assert_equal("quentin@example.com", response.to[0])

    assert_equal("drspin_2003@hotmail.com", response.from[0])

    assert_match(/jalopy/i, response.body)

    assert_match(/Email delivered by Chuckslist/i, response.body)

  end

  def test_fake_email_is_garbaged

    email_test  read_fixture("test_mail_002").join

    response  Mailman.receive(email_test)

    assert_not_equal("quentin@example.com", response.to[0])

    assert_equal("garbage@chuckslist.org", response.to[0])

  end

  def test_regex_match_reply_to_ad_email

    assert_match(/^\d{18}@(chuckslist.com)$/i, "200806159145300001@chuckslist.com")

  end

  def test_regex_match_ad_activation_email

    assert_match(/^([a-zA-Z]{22}@(chuckslist.com))$/i, "abcdefghiJKLmnOPQrstUV@chuckslist.com")

  end

  def test_ad_confirmation_email_is_sent

  end

  def test_ad_confirmation_set_true_when_clicked

  end

  def test_ad_confirmation_email_is_working

  end

end

-

/unit/parent_category_test.rb

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

class ParentCategoryTest < ActiveSupport::TestCase

  def test_truth

    assert true

  end

end

-

/unit/user_test.rb

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

class UserTest < Test::Unit::TestCase

  include AuthenticatedTestHelper

  fixtures :users

  def test_should_create_user

    assert_difference User, :count do

      user  create_user

      assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"

    end

  end

  def test_should_require_password

    assert_no_difference User, :count do

      u  create_user(:password > nil)

      assert u.errors.on(:password)

    end

  end

  def test_should_require_password_confirmation

    assert_no_difference User, :count do

      u  create_user(:password_confirmation > nil)

      assert u.errors.on(:password_confirmation)

    end

  end

  def test_should_require_email

    assert_no_difference User, :count do

      u  create_user(:email > nil)

      assert u.errors.on(:email)

    end

  end

  def test_should_reset_password

    users(:quentin).update_attributes(:password > 'new password', :password_confirmation > 'new password')

    assert_equal users(:quentin), User.authenticate('quentin@example.com', 'new password')

  end

  def test_should_not_rehash_password

    users(:quentin).update_attributes(:email > 'quentin2@example.com')

    assert_equal users(:quentin), User.authenticate('quentin2@example.com', 'test')

  end

  def test_should_authenticate_user

    assert_equal users(:quentin), User.authenticate('quentin@example.com', 'test')

  end

  def test_should_set_remember_token

    users(:quentin).remember_me

    assert_not_nil users(:quentin).remember_token

    assert_not_nil users(:quentin).remember_token_expires_at

  end

  def test_should_unset_remember_token

    users(:quentin).remember_me

    assert_not_nil users(:quentin).remember_token

    users(:quentin).forget_me

    assert_nil users(:quentin).remember_token

  end

  protected

    def create_user(options  {})

      User.create({ :email > 'quire@example.com', :password > 'quire', :password_confirmation > 'quire' }.merge(options))

    end

end