Class: Mocha::Mock

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

Overview

Traditional mock object.

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

Constant Summary collapse

ANCESTOR_INSTANCE_METHODS = 
methods.reject { |m| m =~ /^__.*__$/ }

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name = nil, &block) ⇒ Mock

:stopdoc:



132
133
134
135
136
137
138
 
# File 'lib/mocha/mock.rb', line 132

def initialize(name = nil, &block)
  @name = name || DefaultName.new(self)
  @expectations = ExpectationList.new
  @everything_stubbed = false
  @responder = nil
  instance_eval(&block) if block
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(symbol, *arguments, &block) ⇒ Object 



153
154
155
 
# File 'lib/mocha/mock.rb', line 153

def method_missing(symbol, *arguments, &block)
  __match_invocation__(symbol, arguments, block)
end

Instance Attribute Details

#everything_stubbed ⇒ Object (readonly)

Returns the value of attribute everything_stubbed.



140
141
142
 
# File 'lib/mocha/mock.rb', line 140

def everything_stubbed
  @everything_stubbed
end

#expectations ⇒ Object (readonly)

Returns the value of attribute expectations.



140
141
142
 
# File 'lib/mocha/mock.rb', line 140

def expectations
  @expectations
end

Instance Method Details

#__define_stub_method__(symbol) ⇒ Object 



181
182
183
184
185
186
187
188
189
190
 
# File 'lib/mocha/mock.rb', line 181

def __define_stub_method__(symbol)
  verbose, $VERBOSE = $VERBOSE, nil
  __metaclass__.class_eval(%{
    def #{symbol}(*args, &block)
      __match_invocation__('#{symbol}'.to_sym, args, block)
    end
  })
ensure
  $VERBOSE = verbose
end

#__match_invocation__(symbol, arguments, block) ⇒ Object 



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

def __match_invocation__(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)
      message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
      message << Mockery.instance.mocha_inspect
      raise ExpectationError.new(message, caller)
    end
  end
end

#__verified__?(assertion_counter = nil) ⇒ Boolean

Returns:

  • (Boolean) 


169
170
171
 
# File 'lib/mocha/mock.rb', line 169

def __verified__?(assertion_counter = nil)
  @expectations.verified?(assertion_counter)
end

#expects(method_name_or_hash, backtrace = nil) ⇒ Object Also known as: __expects__

:call-seq: 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\_



41
42
43
44
45
46
47
48
49
50
 
# File 'lib/mocha/mock.rb', line 41

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

#inspect ⇒ Object 



177
178
179
 
# File 'lib/mocha/mock.rb', line 177

def inspect
  mocha_inspect
end

#mocha_inspect ⇒ Object 



173
174
175
 
# File 'lib/mocha/mock.rb', line 173

def mocha_inspect
  @name.mocha_inspect
end

#respond_to?(symbol, include_private = false) ⇒ Boolean

Returns:

  • (Boolean) 


157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/mocha/mock.rb', line 157

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(object) ⇒ Object Also known as: quacks_like

:call-seq: 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



125
126
127
128
 
# File 'lib/mocha/mock.rb', line 125

def responds_like(object)
  @responder = object
  self
end

#stub_everything ⇒ Object 



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

def stub_everything
  @everything_stubbed = true
  ANCESTOR_INSTANCE_METHODS.each { |m| __define_stub_method__(m) }
end

#stubs(method_name_or_hash, backtrace = nil) ⇒ Object Also known as: __stubs__

:call-seq: 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\_



73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/mocha/mock.rb', line 73

def stubs(method_name_or_hash, backtrace = nil)
  iterator = ArgumentIterator.new(method_name_or_hash)
  iterator.each { |*args|
    method_name = args.shift
    __define_stub_method__(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