Class: FlexMock::Expectation

Class | FlexMock::Expectation
In: | lib/flexmock/expectation.rb
Parent: | Object

An Expectation is returned from each `should_receive` message sent to mock object. Each expectation records how a message matching the message name (argument to `should_receive`) and the argument list (given by `with`) should behave. Mock expectations can be recorded by chaining the declaration methods defined in this class.

For example:

      mock.should_receive(:meth).with(args).and_returns(result)

### Methods

and_raise and_return and_return_undefined and_throw and_yield at_least at_most by_default call_count_constrained? eligible? flexmock_verify globally match_arg match_args never new once ordered raises returns returns_undefined throws times to_s twice verify_call with with_any_args with_no_args yields zero_or_more_times

### Attributes

expected_args | [R] |
mock | [RW] |
order_number | [R] |

### Public Class methods

new(mock, sym)

Create an expectation for a method named `sym`.

### Public Instance methods

and_raise(an_exception)
and_raise(SomeException)
and_raise(SomeException, args, ...)

Declares that the method will raise the given exception (with an optional message) when executed.

- If an exception instance is given, then that instance will be raised.
- If an exception class is given, the exception raised with be an instance of that class constructed with `new`. Any additional arguments in the argument list will be passed to the `new` constructor when it is invoked.

`raises` is an alias for `and_raise`.

and_return(value)
and_return(value, value, ...)
and_return { |*args| code }

Declare that the method returns a particular value (when the argument list is matched).

- If a single value is given, it will be returned for all matching calls.
- If multiple values are given, each value will be returned in turn for each successive call. If the number of matching calls is greater than the number of values, the last value will be returned for the extra matching calls.
- If a block is given, it is evaluated on each call and its value is returned.

For example:

     mock.should_receive(:f).returns(12)   # returns 12

     mock.should_receive(:f).with(String). # returns an
       returns { |str| str.upcase }        # upcased string

`returns` is an alias for `and_return`.

and_return_undefined()

Declare that the method returns and undefined object (FlexMock.undefined). Since the undefined object will always return itself for any message sent to it, it is a good "I don‘t care" value to return for methods that are commonly used in method chains.

For example, if m.foo returns the undefined object, then:

       m.foo.bar.baz

returns the undefined object without throwing an exception.

and_throw(a_symbol)
and_throw(a_symbol, value)

Declares that the method will throw the given symbol (with an optional value) when executed.

`throws` is an alias for `and_throw`.

and_yield(value1, value2, ...)

Declare that the mocked method is expected to be given a block and that the block will be called with the values supplied to yield. If the mock is called multiple times, mulitple `and_yield` declarations can be used to supply different values on each call.

An error is raised if the mocked method is not called with a block.

at_least()

Modifies the next call count declarator (`times`, `never`, `once` or `twice`) so that the declarator means the method is called at least that many times.

E.g. method f must be called at least twice:

      mock.should_receive(:f).at_least.twice

at_most()

Modifies the next call count declarator (`times`, `never`, `once` or `twice`) so that the declarator means the method is called at most that many times.

E.g. method f must be called no more than twice

      mock.should_receive(:f).at_most.twice

by_default()
call_count_constrained?()

Is this expectation constrained by any call counts?

eligible?()

Is this expectation eligible to be called again? It is eligible only if all of its count validators agree that it is eligible.

flexmock_verify()

Validate the correct number of calls have been made. Called by the teardown process.

globally()

Modifier that changes the next ordered constraint to apply globally across all mock objects in the container.

match_arg(expected, actual)

Does the expected argument match the corresponding actual value.

match_args(args)

Does the argument list match this expectation‘s argument specification.

never()

Declare that the method is never expected to be called with the given argument list. This may be modified by the `at_least` and `at_most` declarators.

once()

Declare that the method is expected to be called exactly once with the given argument list. This may be modified by the `at_least` and `at_most` declarators.

ordered(group_name=nil)

Declare that the given method must be called in order. All ordered method calls must be received in the order specified by the ordering of the `should_receive` messages. Receiving a methods out of the specified order will cause a test failure.

If the user needs more fine control over ordering (e.g. specifying that a group of messages may be received in any order as long as they all come after another group of messages), a group name may be specified in the `ordered` calls. All messages within the same group may be received in any order.

For example, in the following, messages `flip` and `flop` may be received in any order (because they are in the same group), but must occur strictly after `start` but before `end`. The message `any_time` may be received at any time because it is not ordered.

       m = FlexMock.new
       m.should_receive(:any_time)
       m.should_receive(:start).ordered
       m.should_receive(:flip).ordered(:flip_flop_group)
       m.should_receive(:flop).ordered(:flip_flop_group)
       m.should_receive(:end).ordered

raises(exception, *args)

Alias for and_raise

returns(*args, &block)

Alias for and_return

returns_undefined()

Alias for and_return_undefined

throws(sym, value=nil)

Alias for and_throw

times(limit)

Declare that the method is called `limit` times with the declared argument list. This may be modified by the `at_least` and `at_most` declarators.

to_s()
twice()

Declare that the method is expected to be called exactly twice with the given argument list. This may be modified by the `at_least` and `at_most` declarators.

verify_call(*args)

Verify the current call with the given arguments matches the expectations recorded in this object.

with(*args)

Declare that the method should expect the given argument list.

with_any_args()

Declare that the method can be called with any number of arguments of any type.

with_no_args()

Declare that the method should be called with no arguments.

yields(*yield_values)

Alias for and_yield

zero_or_more_times()

Declare that the method may be called any number of times.

[Validate]