Parent

Class/Module Index [+]

Quicksearch

Mocha::Mock

Traditional mock object.

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

Attributes

everything_stubbed[R]

@private

Public Class Methods

new(mockery, name = nil, &block) click to toggle source

@private

# File lib/mocha/mock.rb, line 197
def initialize(mockery, name = nil, &block)
  @mockery = mockery
  @name = name || DefaultName.new(self)
  @expectations = ExpectationList.new
  @everything_stubbed = false
  @responder = nil
  instance_eval(&block) if block
end

Public Instance Methods

__expectations__() click to toggle source

@private

# File lib/mocha/mock.rb, line 217
def __expectations__
  @expectations
end
__expects__(method_name_or_hash, backtrace = nil) click to toggle source
Alias for: expects
__stubs__(method_name_or_hash, backtrace = nil) click to toggle source
Alias for: stubs
__verified__?(assertion_counter = nil) click to toggle source

@private

# File lib/mocha/mock.rb, line 257
def __verified__?(assertion_counter = nil)
  @expectations.verified?(assertion_counter)
end
any_expectations?() click to toggle source

@private

# File lib/mocha/mock.rb, line 277
def any_expectations?
  @expectations.any?
end
ensure_method_not_already_defined(method_name) click to toggle source

@private

# File lib/mocha/mock.rb, line 272
def ensure_method_not_already_defined(method_name)
  self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
end
expects(method_name_or_hash, backtrace = nil) click to toggle source

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

@param [Symbol,String] method_name name of expected method @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {expects} were called multiple times.

@overload def expects(method_name) @overload def expects(expected_methods_vs_return_values) @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.

@example Expected method invoked once so no error raised

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

@example 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

@example 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

@example 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)
# File lib/mocha/mock.rb, line 52
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
Also aliased as: __expects__
inspect() click to toggle source

@private

# File lib/mocha/mock.rb, line 267
def inspect
  mocha_inspect
end
method_missing(symbol, *arguments, &block) click to toggle source

@private

# File lib/mocha/mock.rb, line 227
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 ExpectationErrorFactory.build(message, caller)
    end
  end
end
mocha_inspect() click to toggle source

@private

# File lib/mocha/mock.rb, line 262
def mocha_inspect
  @name.mocha_inspect
end
quacks_like(responder) click to toggle source
Alias for: responds_like
quacks_like_instance_of(responder_class) click to toggle source
respond_to?(symbol, include_private = false) click to toggle source

@private

# File lib/mocha/mock.rb, line 244
def respond_to?(symbol, include_private = false)
  if @responder then
    if @responder.method(:respond_to?).arity > 1
      @responder.respond_to?(symbol, include_private)
    else
      @responder.respond_to?(symbol)
    end
  else
    @everything_stubbed || @expectations.matches_method?(symbol)
  end
end
responds_like(responder) click to toggle source

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

@param [Object, respond_to?] responder an object used to determine whether {Mock} instance should #respond_to? to an invocation. @return [Mock] the same {Mock} instance, thereby allowing invocations of other {Mock} methods to be chained. @see responds_like_instance_of

@example 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

@example 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

@example 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
sheep_class.number_of_legs # => 4
sheep_class.foo # => raises NoMethodError exception
# File lib/mocha/mock.rb, line 161
def responds_like(responder)
  @responder = responder
  self
end
Also aliased as: quacks_like
responds_like_instance_of(responder_class) click to toggle source

Constrains the {Mock} instance so that it can only expect or stub methods to which an instance of the responder_class responds. The constraint is only applied at method invocation time. Note that the responder instance is instantiated using +Class#allocate+.

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

The {Mock} instance will delegate its #respond_to? method to the responder instance.

@param [Class] responder_class a class used to determine whether {Mock} instance should #respond_to? to an invocation. @return [Mock] the same {Mock} instance, thereby allowing invocations of other {Mock} methods to be chained. @see responds_like

@example Using {responds_like_instance_of}

class Sheep
  def initialize
    raise "some awkward code we don't want to call"
  end
  def chew(grass); end
end

sheep = mock('sheep')
sheep.responds_like_instance_of(Sheep)
sheep.expects(:chew)
sheep.expects(:foo)
sheep.respond_to?(:chew) # => true
sheep.respond_to?(:foo) # => false
sheep.chew
sheep.foo # => raises NoMethodError exception
# File lib/mocha/mock.rb, line 192
def responds_like_instance_of(responder_class)
  responds_like(responder_class.allocate)
end
Also aliased as: quacks_like_instance_of
stub_everything() click to toggle source

@private

# File lib/mocha/mock.rb, line 222
def stub_everything
  @everything_stubbed = true
end
stubs(method_name_or_hash, backtrace = nil) click to toggle source

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

@param [Symbol,String] method_name name of stubbed method @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {stubs} were called multiple times.

@overload def stubs(method_name) @overload def stubs(stubbed_methods_vs_return_values) @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.

@example 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

@example 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)
# File lib/mocha/mock.rb, line 88
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
Also aliased as: __stubs__
unstub(method_name) click to toggle source

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

@param [Symbol] method_name name of method to unstub.

@example 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()
# File lib/mocha/mock.rb, line 110
def unstub(method_name)
  @expectations.remove_all_matching_method(method_name)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.