Class: Mocha::Mock
- Inherits:
-
Object
- Object
- Mocha::Mock
- Defined in:
- lib/mocha/mock.rb
Overview
Traditional mock object.
All methods return an Expectation which can be further modified by methods on Expectation.
Stubs and expectations are basically the same thing. A stub is just an expectation of zero or more invocations. The #stubs method is syntactic sugar to make the intent of the test more explicit.
When a method is invoked on a mock object, the mock object searches through its expectations from newest to oldest to find one that matches the invocation. After the invocation, the matching expectation might stop matching further invocations. For example, an expects(:foo).once expectation only matches once and will be ignored on future invocations while an expects(:foo).at_least_once expectation will always be matched against invocations.
This scheme allows you to:
-
Set up default stubs in your the
setup
method of your test class and override some of those stubs in individual tests. -
Set up different
once
expectations for the same method with different action per invocation. However, it’s better to use the Expectation#returns method with multiple arguments to do this, as described below.
However, there are some possible “gotchas” caused by this scheme:
-
if you create an expectation and then a stub for the same method, the stub will always override the expectation and the expectation will never be met.
-
if you create a stub and then an expectation for the same method, the expectation will match, and when it stops matching the stub will be used instead, possibly masking test failures.
-
if you create different expectations for the same method, they will be invoked in the opposite order than that in which they were specified, rather than the same order.
The best thing to do is not set up multiple expectations and stubs for the same method with exactly the same matchers. Instead, use the Expectation#returns method with multiple arguments to create multiple actions for a method. You can also chain multiple calls to Expectation#returns and Expectation#raises (along with syntactic sugar Expectation#then if desired).
If you want to specify more complex ordering or order invocations across different mock objects, use the Expectation#in_sequence method to explicitly define a total or partial ordering of invocations.
Instance Method Summary collapse
-
#expects(method_name_or_hash, backtrace = nil) ⇒ Expectation
(also: #__expects__)
Adds an expectation that the specified method must be called exactly once with any parameters.
- #respond_to?(symbol, include_private = false) ⇒ Boolean
-
#responds_like(responder) ⇒ Mock
(also: #quacks_like)
Constrains the Mock instance so that it can only expect or stub methods to which
responder
responds. -
#responds_like_instance_of(responder_class) ⇒ Mock
(also: #quacks_like_instance_of)
Constrains the Mock instance so that it can only expect or stub methods to which an instance of the
responder_class
responds. -
#stubs(method_name_or_hash, backtrace = nil) ⇒ Expectation
(also: #__stubs__)
Adds an expectation that the specified method may be called any number of times with any parameters.
- #unstub(method_name) ⇒ Object
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(symbol, *arguments, &block) ⇒ Object
rubocop:disable Style/MethodMissingSuper
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 |
# File 'lib/mocha/mock.rb', line 294 def method_missing(symbol, *arguments, &block) if @responder && !@responder.respond_to?(symbol) raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}" end if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(symbol, *arguments)) matching_expectation_allowing_invocation.invoke(&block) elsif (matching_expectation = all_expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed) if @unexpected_invocation.nil? @unexpected_invocation = UnexpectedInvocation.new(self, symbol, *arguments) matching_expectation.invoke(&block) if matching_expectation = @unexpected_invocation.full_description << @mockery.mocha_inspect else = @unexpected_invocation.short_description end raise ExpectationErrorFactory.build(, caller) end end |
Instance Method Details
#expects(method_name) ⇒ Expectation #expects(expected_methods_vs_return_values) ⇒ Expectation Also known as: __expects__
Adds an expectation that the specified method must be called exactly once with any parameters.
105 106 107 108 109 110 111 112 113 114 |
# File 'lib/mocha/mock.rb', line 105 def expects(method_name_or_hash, backtrace = nil) iterator = ArgumentIterator.new(method_name_or_hash) iterator.each do |*args| method_name = args.shift ensure_method_not_already_defined(method_name) expectation = Expectation.new(self, method_name, backtrace) expectation.returns(args.shift) unless args.empty? @expectations.add(expectation) end end |
#respond_to?(symbol, include_private = false) ⇒ Boolean
329 330 331 |
# File 'lib/mocha/mock.rb', line 329 def respond_to?(symbol, include_private = false) respond_to_missing?(symbol, include_private) end |
#responds_like(responder) ⇒ Mock 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
.
Note that the methods on responder
are never actually invoked.
216 217 218 219 |
# File 'lib/mocha/mock.rb', line 216 def responds_like(responder) @responder = responder self end |
#responds_like_instance_of(responder_class) ⇒ Mock Also known as: quacks_like_instance_of
Constrains the Mocha::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 Mocha::Mock instance will delegate its #respond_to?
method to the responder instance.
Note that the methods on the responder instance are never actually invoked.
249 250 251 |
# File 'lib/mocha/mock.rb', line 249 def responds_like_instance_of(responder_class) responds_like(responder_class.allocate) end |
#stubs(method_name) ⇒ Expectation #stubs(stubbed_methods_vs_return_values) ⇒ Expectation Also known as: __stubs__
Adds an expectation that the specified method may be called any number of times with any parameters.
141 142 143 144 145 146 147 148 149 150 151 |
# File 'lib/mocha/mock.rb', line 141 def stubs(method_name_or_hash, backtrace = nil) iterator = ArgumentIterator.new(method_name_or_hash) iterator.each do |*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) unless args.empty? @expectations.add(expectation) end end |