Class: Mocha::Mock

Class | Mocha::Mock
In: | lib/mocha/mock.rb
Parent: | Object

Traditional mock object.

Methods return an Expectation which can be further modified by methods on Expectation.

### Methods

expects responds_like stubs

### Public Instance methods

expects(method_name) → expectation
expects(method_names_vs_return_values) → last expectation

Adds an expectation that a method identified by `method_name` Symbol/String must be called exactly once with any parameters. Returns the new expectation which can be further modified by methods on Expectation.

      object = mock()
      object.expects(:method1)
      object.method1
      # no error raised

      object = mock()
      object.expects(:method1)
      # error raised, because method1 not called exactly once

If `method_names_vs_return_values` is a `Hash`, an expectation will be set up for each entry using the key as `method_name` and value as `return_value`.

      object = mock()
      object.expects(:method1 => :result1, :method2 => :result2)

      # exactly equivalent to

      object = mock()
      object.expects(:method1).returns(:result1)
      object.expects(:method2).returns(:result2)

Aliased by `__expects__`

responds_like(responder) → mock

Constrains the `mock` so that it can only expect or stub methods to which `responder` responds. The constraint is only applied at method invocation time.

A `NoMethodError` will be raised if the `responder` does not `respond_to?` a method invocation (even if the method has been expected or stubbed).

The `mock` will delegate its `respond_to?` method to the `responder`.

      class Sheep
        def chew(grass); end
        def self.number_of_legs; end
      end

      sheep = mock('sheep')
      sheep.expects(:chew)
      sheep.expects(:foo)
      sheep.respond_to?(:chew) # => true
      sheep.respond_to?(:foo) # => true
      sheep.chew
      sheep.foo
      # no error raised

      sheep = mock('sheep')
      sheep.responds_like(Sheep.new)
      sheep.expects(:chew)
      sheep.expects(:foo)
      sheep.respond_to?(:chew) # => true
      sheep.respond_to?(:foo) # => false
      sheep.chew
      sheep.foo # => raises NoMethodError exception

      sheep_class = mock('sheep_class')
      sheep_class.responds_like(Sheep)
      sheep_class.stubs(:number_of_legs).returns(4)
      sheep_class.expects(:foo)
      sheep_class.respond_to?(:number_of_legs) # => true
      sheep_class.respond_to?(:foo) # => false
      assert_equal 4, sheep_class.number_of_legs
      sheep_class.foo # => raises NoMethodError exception

Aliased by `quacks_like`

stubs(method_name) → expectation
stubs(method_names_vs_return_values) → last expectation

Adds an expectation that a method identified by `method_name` Symbol/String may be called any number of times with any parameters. Returns the new expectation which can be further modified by methods on Expectation.

      object = mock()
      object.stubs(:method1)
      object.method1
      object.method1
      # no error raised

If `method_names_vs_return_values` is a `Hash`, an expectation will be set up for each entry using the key as `method_name` and value as `return_value`.

      object = mock()
      object.stubs(:method1 => :result1, :method2 => :result2)

      # exactly equivalent to

      object = mock()
      object.stubs(:method1).returns(:result1)
      object.stubs(:method2).returns(:result2)

Aliased by `__stubs__`

[Validate]