Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Branch: use-require-re…
Pull request Compare This branch is 1 commit ahead, 611 commits behind master.

Fetching latest commit…

Cannot retrieve the latest commit at this time

..
Failed to load latest commit information.
README.md
be.feature
be_within.feature
change.feature
comparisons.feature
contain_exactly.feature
cover.feature
end_with.feature
equality.feature
exist.feature
include.feature
match.feature
output.feature
predicates.feature
raise_error.feature
respond_to.feature
satisfy.feature
start_with.feature
throw_symbol.feature
types.feature
yield.feature

README.md

Built-in Matchers

rspec-expectations ships with a number of built-in matchers. Each matcher can be used with expect(..).to or expect(..).not_to to define positive and negative expectations respectively on an object. Most matchers can also be accessed using the (...).should and (...).should_not syntax, see using should syntax for why we recommend using expect.

e.g.

expect(result).to   eq(3)
expect(list).not_to be_empty
pi.should be > 3

Object identity

expect(actual).to be(expected) # passes if actual.equal?(expected)

Object equivalence

expect(actual).to eq(expected) # passes if actual == expected

Optional APIs for identity/equivalence

expect(actual).to eql(expected)   # passes if actual.eql?(expected)
expect(actual).to equal(expected) # passes if actual.equal?(expected)

# NOTE: `expect` does not support `==` matcher.

Comparisons

expect(actual).to be >  expected
expect(actual).to be >= expected
expect(actual).to be <= expected
expect(actual).to be <  expected
expect(actual).to match(/expression/)
expect(actual).to be_within(delta).of(expected)

# NOTE: `expect` does not support `=~` matcher.

Types/classes

expect(actual).to be_instance_of(expected)
expect(actual).to be_kind_of(expected)

Truthiness and existentialism

expect(actual).to be_truthy # passes if actual is truthy (not nil or false)
expect(actual).to be true   # passes if actual == true
expect(actual).to be_falsey # passes if actual is falsy (nil or false)
expect(actual).to be false  # passes if actual == false
expect(actual).to be_nil    # passes if actual is nil

Expecting errors

expect { ... }.to raise_error
expect { ... }.to raise_error(ErrorClass)
expect { ... }.to raise_error("message")
expect { ... }.to raise_error(ErrorClass, "message")

Expecting throws

expect { ... }.to throw_symbol
expect { ... }.to throw_symbol(:symbol)
expect { ... }.to throw_symbol(:symbol, 'value')

Predicate matchers

expect(actual).to be_xxx         # passes if actual.xxx?
expect(actual).to have_xxx(:arg) # passes if actual.has_xxx?(:arg)

Examples

expect([]).to      be_empty
expect(:a => 1).to have_key(:a)

Collection membership

expect(actual).to include(expected)
expect(array).to match_array(expected_array)
# ...which is the same as:
expect(array).to contain_exactly(individual, elements)

Examples

expect([1, 2, 3]).to     include(1)
expect([1, 2, 3]).to     include(1, 2)
expect(:a => 'b').to     include(:a => 'b')
expect("this string").to include("is str")
expect([1, 2, 3]).to     contain_exactly(2, 1, 3)
expect([1, 2, 3]).to     match_array([3, 2, 1])

Ranges (1.9 only)

expect(1..10).to cover(3)
Something went wrong with that request. Please try again.