Mocha::API

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 #) 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 

    # File lib/mocha/api.rb, line 40
40:     def mock(*arguments, &block)
41:       name = arguments.shift if arguments.first.is_a?(String)
42:       expectations = arguments.shift || {}
43:       mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
44:       mock.expects(expectations)
45:       mock
46:     end

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)

     # File lib/mocha/api.rb, line 122
122:     def sequence(name)
123:       Sequence.new(name)
124:     end

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'))

     # File lib/mocha/api.rb, line 148
148:     def states(name)
149:       Mockery.instance.new_state_machine(name)
150:     end

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 #) 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

    # File lib/mocha/api.rb, line 75
75:     def stub(*arguments, &block)
76:       name = arguments.shift if arguments.first.is_a?(String)
77:       expectations = arguments.shift || {}
78:       stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
79:       stub.stubs(expectations)
80:       stub
81:     end

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 #.

  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

     # File lib/mocha/api.rb, line 100
100:     def stub_everything(*arguments, &block)
101:       name = arguments.shift if arguments.first.is_a?(String)
102:       expectations = arguments.shift || {}
103:       stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
104:       stub.stub_everything
105:       stub.stubs(expectations)
106:       stub
107:     end