Module: Mocha::API

Includes:
ParameterMatchers
Included in:
MiniTest::Unit::TestCase, Test::Unit::TestCase
Defined in:
lib/mocha/api.rb

Overview

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

Defined Under Namespace

Classes: HaveReceived

Instance Method Summary collapse

Methods included from ParameterMatchers

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

Instance Method Details

#assert_received(mock, expected_method_name) {|matcher| ... } ⇒ Object

Asserts that the given mock received the given method.

Examples:

assert_received(mock, :to_s)
assert_received(Radio, :new) {|expect| expect.with(1041) }
assert_received(radio, :volume) {|expect| expect.with(11).twice }

Yields:

  • (matcher) 


159
160
161
162
163
 
# File 'lib/mocha/api.rb', line 159

def assert_received(mock, expected_method_name)
  matcher = have_received(expected_method_name)
  yield(matcher) if block_given?
  assert matcher.matches?(mock), matcher.failure_message
end

#have_received(expected_method_name) ⇒ Object

:call-seq:

should have_received(method).with(arguments).times(times)

Ensures that the given mock received the given method.

Examples:

mock.should have_received(:to_s)
Radio.should have_received(:new).with(1041)
radio.should have_received(:volume).with(11).twice



224
225
226
 
# File 'lib/mocha/api.rb', line 224

def have_received(expected_method_name)
  HaveReceived.new(expected_method_name)
end

#mocha_setup ⇒ Object

:nodoc:



228
229
 
# File 'lib/mocha/api.rb', line 228

def mocha_setup # :nodoc:
end

#mocha_teardown ⇒ Object

:nodoc:



235
236
237
238
 
# File 'lib/mocha/api.rb', line 235

def mocha_teardown # :nodoc:
  Mockery.instance.teardown
  Mockery.reset_instance
end

#mocha_verify(assertion_counter = nil) ⇒ Object

:nodoc:



231
232
233
 
# File 'lib/mocha/api.rb', line 231

def mocha_verify(assertion_counter = nil) # :nodoc:
  Mockery.instance.verify(assertion_counter)
end

#mock(*arguments, &block) ⇒ Object

:call-seq: mock(name, &block) -> mock object

mock(expected_methods = {}, &block) -> mock object
mock(name, expected_methods = {}, &block) -> mock object

Creates a mock object.

name is a String identifier for the mock object.

expected_methods is a Hash with expected method name symbols as keys and corresponding return values as values.

Note that (contrary to expectations set up by #stub) these expectations must be fulfilled during the test.

def test_product
  product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
  assert_equal 'ipod', product.manufacturer
  assert_equal 100, product.price
  # an error will be raised unless both Product#manufacturer and Product#price have been called
end

block is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.

def test_product
  product = mock('ipod_product') do
    expects(:manufacturer).returns('ipod')
    expects(:price).returns(100)
  end
  assert_equal 'ipod', product.manufacturer
  assert_equal 100, product.price
  # an error will be raised unless both Product#manufacturer and Product#price have been called
end



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(name) ⇒ Object

:call-seq: sequence(name) -> sequence

Returns a new sequence that is used to constrain the order in which expectations can occur.

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

See also Expectation#in_sequence.

breakfast = sequence('breakfast')

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



122
123
124
 
# File 'lib/mocha/api.rb', line 122

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

#states(name) ⇒ Object

:call-seq: states(name) -> state_machine

Returns a new state_machine that is 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.

See also Expectation#then, Expectation#when and StateMachine.

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

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



148
149
150
 
# File 'lib/mocha/api.rb', line 148

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

#stub(*arguments, &block) ⇒ Object

:call-seq: stub(name, &block) -> mock object

stub(stubbed_methods = {}, &block) -> mock object
stub(name, stubbed_methods = {}, &block) -> mock object

Creates a mock object.

name is a String identifier for the mock object.

stubbed_methods is a Hash with stubbed method name symbols as keys and corresponding return values as values. Note that (contrary to expectations set up by #mock) these expectations need not be fulfilled during the test.

def test_product
  product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
  assert_equal 'ipod', product.manufacturer
  assert_equal 100, product.price
  # an error will not be raised even if Product#manufacturer and Product#price have not been called
end

block is an optional block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.

def test_product
  product = stub('ipod_product') do
    stubs(:manufacturer).returns('ipod')
    stubs(:price).returns(100)
  end
  assert_equal 'ipod', product.manufacturer
  assert_equal 100, product.price
  # an error will not be raised even if Product#manufacturer and Product#price have not been called
end



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

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

#stub_everything(*arguments, &block) ⇒ Object

:call-seq: stub_everything(name, &block) -> mock object

stub_everything(stubbed_methods = {}, &block) -> mock object
stub_everything(name, stubbed_methods = {}, &block) -> mock object

Creates a mock object that accepts calls to any method.

By default it will return nil for any method call.

block is a block to be evaluated against the mock object instance, giving an alernative way to set up expectations & stubs.

name and stubbed_methods work in the same way as for #stub.

def test_product
  product = stub_everything('ipod_product', :price => 100)
  assert_nil product.manufacturer
  assert_nil product.any_old_method
  assert_equal 100, product.price
end



100
101
102
103
104
105
106
107
 
# File 'lib/mocha/api.rb', line 100

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