Ensures that the attribute can be set on mass update.

  it { should_not allow_mass_assignment_of(:password) }
  it { should allow_mass_assignment_of(:first_name) }

Ensures that the attribute can be set to the given value.

Options:

• with_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :invalid.

Example:

  it { should_not allow_value('bad').for(:isbn) }
  it { should allow_value("isbn 1 2345 6789 0").for(:isbn) }

Ensure that the belongs_to relationship exists.

  it { should belong_to(:parent) }

Ensure that the attribute’s value is in the range specified

Options:

• in_range - the range of allowed values for this attribute
• with_low_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :inclusion.
• with_high_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :inclusion.

Example:

  it { should ensure_inclusion_of(:age).in_range(0..100) }

Ensures that the length of the attribute is validated.

Options:

• is_at_least - minimum length of this attribute
• is_at_most - maximum length of this attribute
• is_equal_to - exact requred length of this attribute
• with_short_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :too_short.
• with_long_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :too_long.
• with_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :wrong_length. Used in conjunction with is_equal_to.

Examples:

  it { should ensure_length_of(:password).
                is_at_least(6).
                is_at_most(20) }
  it { should ensure_length_of(:name).
                is_at_least(3).
                with_short_message(/not long enough/) }
  it { should ensure_length_of(:ssn).
                is_equal_to(9).
                with_message(/is invalid/) }

Ensures that the has_and_belongs_to_many relationship exists, and that the join table is in place.

  it { should have_and_belong_to_many(:posts) }

Ensures the database column exists.

Options:

• of_type - db column type (:integer, :string, etc.)
• with_options - same options available in migrations (:default, :null, :limit, :precision, :scale)

Examples:

  it { should_not have_db_column(:admin).of_type(:boolean) }
  it { should have_db_column(:salary).
                of_type(:decimal).
                with_options(:precision => 10, :scale => 2) }

Ensures that there are DB indices on the given columns or tuples of columns.

Options:

• unique - whether or not the index has a unique constraint. Use true to explicitly test for a unique constraint. Use false to explicitly test for a non-unique constraint. Use nil if you don’t care whether the index is unique or not. Default = nil

Examples:

  it { should have_index(:age) }
  it { should have_index([:commentable_type, :commentable_id]) }
  it { should have_index(:ssn).unique(true) }

Ensures that the has_many relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.

Options:

• through - association name for has_many :through
• dependent - tests that the association makes use of the dependent option.

Example:

  it { should_have_many(:friends) }
  it { should_have_many(:enemies).through(:friends) }
  it { should_have_many(:enemies).dependent(:destroy) }

Ensures that the model has a method named scope_call that returns a NamedScope object with the proxy options set to the options you supply. scope_call can be either a symbol, or a Ruby expression in a String which will be evaled. The eval’d method call has access to all the same instance variables that an example would.

Options:

 * <tt>in_context</tt> - Any of the options that the named scope would
   pass on to find.

Example:

  it { should have_named_scope(:visible).
                finding(:conditions => {:visible => true}) }

Passes for

  named_scope :visible, :conditions => {:visible => true}

Or for

  def self.visible
    scoped(:conditions => {:visible => true})
  end

You can test lambdas or methods that return ActiveRecord#scoped calls:

  it { should have_named_scope('recent(5)').finding(:limit => 5) }
  it { should have_named_scope('recent(1)').finding(:limit => 1) }

Passes for

  named_scope :recent, lambda {|c| {:limit => c}}

Or for

  def self.recent(c)
    scoped(:limit => c)
  end

Ensure that the has_one relationship exists. Will also test that the associated table has the required columns. Works with polymorphic associations.

Options:

• :dependent - tests that the association makes use of the dependent option.

Example:

  it { should have_one(:god) } # unless hindu

Ensures that the attribute cannot be changed once the record has been created.

  it { should have_readonly_attributes(:password) }

Ensures that the model cannot be saved the given attribute is not accepted.

Options:

• with_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :accepted.

Example:

  it { should validate_acceptance_of(:eula) }

Ensure that the attribute is numeric

Options:

• with_message - value the test expects to find in errors.on(:attribute). Regexp or string. Defaults to the translation for :not_a_number.

Example:

  it { should validate_numericality_of(:age) }

Ensures that the model is not valid if the given attribute is not present.

Options:

• with_message - value the test expects to find in errors.on(:attribute). Regexp or String. Defaults to the translation for :blank.

Examples:

  it { should validate_presence_of(:name) }
  it { should validate_presence_of(:name).
                with_message(/is not optional/) }

Ensures that the model is invalid if the given attribute is not unique.

Internally, this uses values from existing records to test validations, so this will always fail if you have not saved at least one record for the model being tested, like so:

  describe User do
    before(:each) { User.create!(:email => 'address@example.com') }
    it { should validate_uniqueness_of(:email) }
  end

Options:

• with_message - value the test expects to find in errors.on(:attribute). Regexp or String. Defaults to the translation for :taken.
• scoped_to - field(s) to scope the uniqueness to.
• case_insensitive - ensures that the validation does not check case. Off by default. Ignored by non-text attributes.

Examples:

  it { should validate_uniqueness_of(:keyword) }
  it { should validate_uniqueness_of(:keyword).with_message(/dup/) }
  it { should validate_uniqueness_of(:email).scoped_to(:name) }
  it { should validate_uniqueness_of(:email).
                scoped_to(:first_name, :last_name) }
  it { should validate_uniqueness_of(:keyword).case_insensitive }