= TesterXtreme

The Tester Xtreme plugin is a way to distill common testing patterns into easy-to-use macros that
are added as class methods to your test cases.  There are currently macros for both unit (ActiveRecord 
model) and functional (ActionController controllers) tests.

== Unit Test Macros

=== Validation Tests

Each of the validation testing macros checks to make sure there is an appropriate validation method 
defined in the model for each attribute specified.

*should_require*

Ensures that +validates_presence_of+ was used.

*should_require_numeric*

Ensures that +validates_numericality_of+ was used.

*should_require_unique*

Ensures that +validates_uniqueness_of+ was used.

*should_protect*

Ensures that +attr_protected+ was used for this attribute.

*Usage*:

  class UserTest < ActiveSupport::TestCase
    should_require :first_name, :last_name
    should_require_unique :username
    should_require_numeric :friends_count
    should_protect :hashed_password
  end

=== Association Tests

Each of the association testing macros checks to make sure the correct associations were defined on 
this model.  The names map directly to the association definitions:

*should_have_many*

Ensures that +has_many+ was used.

*should_belong_to*

Ensures that +belongs_to+ was used.

*should_have_one*

Ensures that +has_one+ was used.

*should_have_and_belong_to_many*

Ensures that +has_and_belongs_to_many+ was used.

*Usage*:

  class UserTest < ActiveSupport::TestCase
    should_have_many :friends
    should_belong_to :organization
    should_have_one :credit_card
    should_have_and_belong_to_many :categories
  end

== Functional Test Macros

Each of the functional testing macros require that you first request an action on the controller.  To
accomplish this, the 4 standard actions are implemented as class methods for the test:

* get
* post
* put
* delete

In addition to simple requests, you can also specify parameters and initial states:

  get(:show){ User.expects(:find).returns(mocked_user) }.with(:id => 1)
  post(:create).with(:username => 'foobar')

From here, you can use the macros to define certain expectations on the controller:

*should_assign*

Asserts that the specified variable is set as an instance variable.

*should_not_assign*

Asserts that the specified variable is *not* set as an instance variable.

*should_use_filter*

Asserts that the designated filter method is run.

*should_not_use_filter*

Asserts that the designated filter method is *not* run.

*should_render*

Asserts that the response for the action is successful and that the specified template is rendered.

*should_set_flash*

Asserts that the specified key and value was set in the flash collection.

*should_set_session*

Asserts that the specified variable was set in session.

*should_redirect_to*

Asserts that the response was a redirect and that the action redirects to the specified route.

*Usage*:

  class UsersController < ActionController::TestCase
    get(:new).should_render(:new)
    post(:create).with(:username => 'foo').should_redirect_to(:new_user_url)
    delete(:destroy).should_set_flash(:notice, 'You must log in')
    get(:show).with(:id => 1).should_use_filter(:check_for_current_user)
    get(:show).with({:id => 1}, {:user_id => 3}).should_assign(:current_user)
  end

= Credits

Copyright (c) 2007 Ben Scofield, released under the MIT license