Class: Mocha::Mock

Inherits:
Object show all
Defined in:
lib/mocha/mock.rb

Overview

Traditional mock object.

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

Instance Method Summary (collapse)

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

- (Object) method_missing(symbol, *arguments, &block) 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/mocha/mock.rb', line 194

def method_missing(symbol, *arguments, &block)
  if @responder and not @responder.respond_to?(symbol)
    raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
  end
  if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
    matching_expectation_allowing_invocation.invoke(&block)
  else
    if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
      matching_expectation.invoke(&block) if matching_expectation
      message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
      message << @mockery.mocha_inspect
      raise ExpectationError.new(message, caller)
    end
  end
end

Instance Method Details

- (Expectation) expects(method_name) - (Expectation) expects(expected_methods_vs_return_values) Also known as: __expects__

Adds an expectation that the specified method must be called exactly once with any parameters.

Examples:

Expected method invoked once so no error raised

object = mock()
object.expects(:expected_method)
object.expected_method

Expected method not invoked so error raised

object = mock()
object.expects(:expected_method)
# error raised when test completes, because expected_method not called exactly once

Expected method invoked twice so error raised

object = mock()
object.expects(:expected_method)
object.expected_method
object.expected_method # => error raised when expected method invoked second time

Setup multiple expectations using expected_methods_vs_return_values.

object = mock()
object.expects(:expected_method_one => :result_one, :expected_method_two => :result_two)

# is exactly equivalent to

object = mock()
object.expects(:expected_method_one).returns(:result_one)
object.expects(:expected_method_two).returns(:result_two)

Parameters:

  • method_name (Symbol, String) —

    name of expected method

  • expected_methods_vs_return_values (Hash) —

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

Returns:



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/mocha/mock.rb', line 51

def expects(method_name_or_hash, backtrace = nil)
  iterator = ArgumentIterator.new(method_name_or_hash)
  iterator.each { |*args|
    method_name = args.shift
    ensure_method_not_already_defined(method_name)
    expectation = Expectation.new(self, method_name, backtrace)
    expectation.returns(args.shift) if args.length > 0
    @expectations.add(expectation)
  }
end

- (Mock) responds_like(responder) Also known as: quacks_like

Constrains the Mocha::Mock instance 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 Mocha::Mock instance will delegate its #respond_to? method to the responder.

Examples:

Normal mocking

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

Using #responds_like with an instance method

class Sheep
  def chew(grass); end
end

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

Using #responds_like with a class method

class Sheep
  def self.number_of_legs; end
end

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

Parameters:

  • responder (Object, #respond_to?) —

    an object used to determine whether Mocha::Mock instance should #respond_to? to an invocation.

Returns:



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

def responds_like(responder)
  @responder = responder
  self
end

- (Expectation) stubs(method_name) - (Expectation) stubs(stubbed_methods_vs_return_values) Also known as: __stubs__

Adds an expectation that the specified method may be called any number of times with any parameters.

Examples:

No error raised however many times stubbed method is invoked

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

Setup multiple expectations using stubbed_methods_vs_return_values.

object = mock()
object.stubs(:stubbed_method_one => :result_one, :stubbed_method_two => :result_two)

# is exactly equivalent to

object = mock()
object.stubs(:stubbed_method_one).returns(:result_one)
object.stubs(:stubbed_method_two).returns(:result_two)

Parameters:

  • method_name (Symbol, String) —

    name of stubbed method

  • 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 #stubs were called multiple times.

Returns:



87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/mocha/mock.rb', line 87

def stubs(method_name_or_hash, backtrace = nil)
  iterator = ArgumentIterator.new(method_name_or_hash)
  iterator.each { |*args|
    method_name = args.shift
    ensure_method_not_already_defined(method_name)
    expectation = Expectation.new(self, method_name, backtrace)
    expectation.at_least(0)
    expectation.returns(args.shift) if args.length > 0
    @expectations.add(expectation)
  }
end

- (Object) unstub(method_name)

Removes the specified stubbed method (added by calls to #expects or #stubs) and all expectations associated with it.

Examples:

Invoking an unstubbed method causes error to be raised

object = mock('mock') do
object.stubs(:stubbed_method).returns(:result_one)
object.stubbed_method # => :result_one
object.unstub(:stubbed_method)
object.stubbed_method # => unexpected invocation: #<Mock:mock>.stubbed_method()

Parameters:

  • method_name (Symbol) —

    name of method to unstub.



109
110
111
 
# File 'lib/mocha/mock.rb', line 109

def unstub(method_name)
  @expectations.remove_all_matching_method(method_name)
end