Module: Mocha::API

Includes:
ParameterMatchers
Defined in:
lib/mocha/api.rb

Overview

Methods added to Test::Unit::TestCase or equivalent.

Instance Method Summary (collapse)

Methods included from ParameterMatchers

#Not, #all_of, #any_of, #any_parameters, #anything, #equals, #has_entries, #has_entry, #has_equivalent_query_string, #has_key, #has_value, #includes, #instance_of, #is_a, #kind_of, #optionally, #regexp_matches, #responds_with, #yaml_equivalent

Instance Method Details

- (Mock) mock(name, &block) - (Mock) mock(expected_methods_vs_return_values = {}, &block) - (Mock) mock(name, expected_methods_vs_return_values = {}, &block)

Builds a new mock object

Examples:

Using expected_methods_vs_return_values Hash to setup expectations.

def test_motor_starts_and_stops
  motor = mock('motor', :start => true, :stop => true)
  assert motor.start
  assert motor.stop
  # an error will be raised unless both Motor#start and Motor#stop have been called
end

Using the optional block to setup expectations & stubbed methods.

def test_motor_starts_and_stops
  motor = mock('motor') do
    expects(:start).with(100.rpm).returns(true)
    stubs(:stop).returns(true)
  end
  assert motor.start(100.rpm)
  assert motor.stop
  # an error will only be raised if Motor#start(100.rpm) has not been called
end

Parameters:

  • name (String) —

    identifies mock object in error messages.

  • expected_methods_vs_return_values (Hash) —

    expected method name symbols as keys and corresponding return values as values - these expectations are setup as if Mock#expects were called multiple times.

Yields:

  • optional block to be evaluated against the mock object instance, giving an alternative way to setup expectations.

Returns:

  • (Mock) —

    a new mock object



40
41
42
43
44
45
46
 
# File 'lib/mocha/api.rb', line 40

def mock(*arguments, &block)
  name = arguments.shift if arguments.first.is_a?(String)
  expectations = arguments.shift || {}
  mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
  mock.expects(expectations)
  mock
end

- (Sequence) sequence(name)

Builds a new sequence which can be used to constrain the order in which expectations can occur.

Specify that an expected invocation must occur within a named Sequence by using Expectation#in_sequence.

Examples:

Ensure methods on egg are invoked in correct order.

breakfast = sequence('breakfast')

egg = mock('egg') do
  expects(:crack).in_sequence(breakfast)
  expects(:fry).in_sequence(breakfast)
  expects(:eat).in_sequence(breakfast)
end

Returns:

See Also:



128
129
130
 
# File 'lib/mocha/api.rb', line 128

def sequence(name)
  Sequence.new(name)
end

- (StateMachine) states(name)

Builds a new state machine which can be used to constrain the order in which expectations can occur.

Specify the initial state of the state machine by using StateMachine#starts_as.

Specify that an expected invocation should change the state of the state machine by using Expectation#then.

Specify that an expected invocation should be constrained to occur within a particular state by using Expectation#when.

A test can contain multiple state machines.

Examples:

Constrain expected invocations to occur in particular states.

power = states('power').starts_as('off')

radio = mock('radio') do
  expects(:switch_on).then(power.is('on'))
  expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
  expects(:adjust_volume).with(+5).when(power.is('on'))
  expects(:select_channel).with('BBC World Service').when(power.is('on'))
  expects(:adjust_volume).with(-5).when(power.is('on'))
  expects(:switch_off).then(power.is('off'))
end

Returns:

See Also:



158
159
160
 
# File 'lib/mocha/api.rb', line 158

def states(name)
  Mockery.instance.new_state_machine(name)
end

- (Mock) stub(name, &block) - (Mock) stub(stubbed_methods_vs_return_values = {}, &block) - (Mock) stub(name, stubbed_methods_vs_return_values = {}, &block)

Builds a new mock object

Examples:

Using stubbed_methods_vs_return_values Hash to setup stubbed methods.

def test_motor_starts_and_stops
  motor = mock('motor', :start => true, :stop => true)
  assert motor.start
  assert motor.stop
  # an error will not be raised even if either Motor#start or Motor#stop has not been called
end

Using the optional block to setup expectations & stubbed methods.

def test_motor_starts_and_stops
  motor = mock('motor') do
    expects(:start).with(100.rpm).returns(true)
    stubs(:stop).returns(true)
  end
  assert motor.start(100.rpm)
  assert motor.stop
  # an error will only be raised if Motor#start(100.rpm) has not been called
end

Parameters:

  • name (String) —

    identifies mock object in error messages.

  • stubbed_methods_vs_return_values (Hash) —

    stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if Mock#stubs were called multiple times.

Yields:

  • optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.

Returns:

  • (Mock) —

    a new mock object



77
78
79
80
81
82
83
 
# File 'lib/mocha/api.rb', line 77

def stub(*arguments, &block)
  name = arguments.shift if arguments.first.is_a?(String)
  expectations = arguments.shift || {}
  stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
  stub.stubs(expectations)
  stub
end

- (Mock) stub_everything(name, &block) - (Mock) stub_everything(stubbed_methods_vs_return_values = {}, &block) - (Mock) stub_everything(name, stubbed_methods_vs_return_values = {}, &block)

Builds a mock object that accepts calls to any method. By default it will return nil for any method call.

Examples:

Ignore invocations of irrelevant methods.

def test_motor_stops
  motor = stub_everything('motor', :stop => true)
  assert_nil motor.irrelevant_method_1 # => no error raised
  assert_nil motor.irrelevant_method_2 # => no error raised
  assert motor.stop
end

Parameters:

  • name (String) —

    identifies mock object in error messages.

  • stubbed_methods_vs_return_values (Hash) —

    stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if Mock#stubs were called multiple times.

Yields:

  • optional block to be evaluated against the mock object instance, giving an alternative way to setup stubbed methods.

Returns:

  • (Mock) —

    a new mock object



103
104
105
106
107
108
109
110
 
# File 'lib/mocha/api.rb', line 103

def stub_everything(*arguments, &block)
  name = arguments.shift if arguments.first.is_a?(String)
  expectations = arguments.shift || {}
  stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
  stub.stub_everything
  stub.stubs(expectations)
  stub
end