Using expected_methods_vs_return_values Hash to setup expectations.
+
+
+
deftest_motor_starts_and_stops
+ motor=mock('motor',:start=>true,:stop=>true)
+ assertmotor.start
+ assertmotor.stop
+ # an error will be raised unless both Motor#start and Motor#stop have been called
+end
+
+
+
+
Using the optional block to setup expectations & stubbed methods
+[deprecated].
+
+
+
deftest_motor_starts_and_stops
+ motor=mock('motor')do
+ expects(:start).with(100.rpm).returns(true)
+ stubs(:stop).returns(true)
+ end
+ assertmotor.start(100.rpm)
+ assertmotor.stop
+ # an error will only be raised if Motor#start(100.rpm) has not been called
+end
expected method name symbols as keys and corresponding return values as
+values - these expectations are setup as if Mock#expects were called
+multiple times.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block to be evaluated in the context of the mock object instance,
+giving an alternative way to setup stubbed methods.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
note that the block is evaulated by calling Mock#instance_eval and so
+things like instance variables declared in the test will not be available
+within the block.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
deprecated: use Object#tap or define stubs/expectations with an explicit
+receiver instead.
Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
+
+
+
deftest_motor_starts_and_stops
+ motor=stub('motor',:start=>true,:stop=>true)
+ assertmotor.start
+ assertmotor.stop
+ # an error will not be raised even if either Motor#start or Motor#stop has not been called
+end
+
+
+
+
Using the optional block to setup expectations & stubbed methods
+[deprecated].
+
+
+
deftest_motor_starts_and_stops
+ motor=stub('motor')do
+ expects(:start).with(100.rpm).returns(true)
+ stubs(:stop).returns(true)
+ end
+ assertmotor.start(100.rpm)
+ assertmotor.stop
+ # an error will only be raised if Motor#start(100.rpm) has not been called
+end
stubbed method name symbols as keys and corresponding return values as
+values - these stubbed methods are setup as if Mock#stubs were called
+multiple times.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block to be evaluated in the context of the mock object instance,
+giving an alternative way to setup stubbed methods.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
note that the block is evaulated by calling Mock#instance_eval and so
+things like instance variables declared in the test will not be available
+within the block.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
deprecated: use Object#tap or define stubs/expectations with an explicit
+receiver instead.
stubbed method name symbols as keys and corresponding return values as
+values - these stubbed methods are setup as if Mock#stubs were called
+multiple times.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block to be evaluated in the context of the mock object instance,
+giving an alternative way to setup stubbed methods.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
note that the block is evaulated by calling Mock#instance_eval and so
+things like instance variables declared in the test will not be available
+within the block.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
deprecated: use Object#tap or define stubs/expectations with an explicit
+receiver instead.
This class allows you to determine what should happen under certain
+circumstances. In each scenario, Mocha can be configured to do nothing, display a warning message, or raise an exception. The relevant scenario is identified using one of the following
+symbols:
+
+
:stubbing_method_unnecessarily This is useful for identifying
+unused stubs. Unused stubs are often accidentally introduced when code is
+refactored.
+Allowed by default.
+
+
:stubbing_non_existent_method - This is useful if you want to
+ensure that methods you're mocking really exist. A common criticism of
+unit tests with mock objects is that such a test may (incorrectly) pass
+when an equivalent non-mocking test would (correctly) fail. While you
+should always have some integration tests, particularly for critical
+business functionality, this Mocha configuration setting should catch
+scenarios when mocked methods and real methods have become misaligned.
+Allowed by default.
+
+
:stubbing_non_public_method - Many people think that it's
+good practice only to mock public methods. This is one way to prevent your
+tests being too tightly coupled to the internal implementation of a class.
+Such tests tend to be very brittle and not much use when refactoring.
+Allowed by default.
+
+
:stubbing_method_on_non_mock_object - If you like the idea of
+mocking roles not objects and
+you don't like stubbing concrete classes, this is the setting for you.
+However, while this restriction makes a lot of sense in Java with its
+explicit interfaces, it may be moot in Ruby where roles are probably best
+represented as Modules. Allowed by default.
+
+
:stubbing_method_on_nil - This is usually done accidentally,
+but there might be rare cases where it is intended. Prevented by default.
+
+
+
Typically the configuration would be set globally in a
+test_helper.rb or spec_helper.rb file. However,
+it can also be temporarily overridden locally using the block syntax of the
+relevant method. In the latter case, the original configuration settings
+are restored when the block is exited.
one of :stubbing_method_unnecessarily,
+:stubbing_method_on_non_mock_object,
+:stubbing_non_existent_method,
+:stubbing_non_public_method,
+:stubbing_method_on_nil.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block during which the configuration change will be changed before
+being returned to its original value at the end of the block.
+
+
+
+
+
+
+
+
+
+
+
+
+82
+83
+84
+
+
+
# File 'lib/mocha/configuration.rb', line 82
+
+defallow(action,&block)
+ change_configaction,:allow,&block
+end
+
+
+
+
+
+
+
+
+ .prevent(action) { ... } ⇒ Object
+
+
+
+
+
+
+
+
+
Raise a StubbingError if if the specified action is
+attempted.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ action
+
+
+ (Symbol)
+
+
+
+ —
+
+
one of :stubbing_method_unnecessarily,
+:stubbing_method_on_non_mock_object,
+:stubbing_non_existent_method,
+:stubbing_non_public_method,
+:stubbing_method_on_nil.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block during which the configuration change will be changed before
+being returned to its original value at the end of the block.
+
+
+
+
+
+
+
+
+
+
+
+
+108
+109
+110
+
+
+
# File 'lib/mocha/configuration.rb', line 108
+
+defprevent(action,&block)
+ change_configaction,:prevent,&block
+end
one of :stubbing_method_unnecessarily,
+:stubbing_method_on_non_mock_object,
+:stubbing_non_existent_method,
+:stubbing_non_public_method,
+:stubbing_method_on_nil.
+
+
+
+
+
+
+
Yields:
+
+
+
+
+
+
+
+
+
+
+
+
optional block during which the configuration change will be changed before
+being returned to its original value at the end of the block.
+
+
+
+
+
+
+
+
+
+
+
+
+95
+96
+97
+
+
+
# File 'lib/mocha/configuration.rb', line 95
+
+defwarn_when(action,&block)
+ change_configaction,:warn,&block
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/Mocha/Expectation.html b/doc/Mocha/Expectation.html
new file mode 100644
index 000000000..be32dd13a
--- /dev/null
+++ b/doc/Mocha/Expectation.html
@@ -0,0 +1,2711 @@
+
+
+
+
+
+
+ Class: Mocha::Expectation
+
+ — Mocha 1.7.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Modifies expectation so that when the expected method is called, it yields
+multiple times per invocation with the specified
+parameter_groups.
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
When the expected_method is called, the stub will invoke the
+block twice, the first time it passes 'result_1',
+'result_2' as the parameters, and the second time it passes
+'result_3' as the parameters.
Modifies expectation so that when the expected method is called, it raises
+the specified exception with the specified
+message i.e. calls Kernel#raise(exception, message).
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Raise specified exception if expected method is invoked.
+
+
+
object=stub()
+object.stubs(:expected_method).raises(Exception,'message')
+object.expected_method# => raises exception of class Exception and with message 'message'
+
+
+
+
Raise custom exception with extra constructor parameters by passing in an
+instance of the exception.
+
+
+
object=stub()
+object.stubs(:expected_method).raises(MyException.new('message',1,2,3))
+object.expected_method# => raises the specified instance of MyException
+
+
+
+
Raise different exceptions on consecutive invocations of the expected
+method.
+
+
+
object=stub()
+object.stubs(:expected_method).raises(Exception1).then.raises(Exception2)
+object.expected_method# => raises exception of class Exception1
+object.expected_method# => raises exception of class Exception2
+
+
+
+
Raise an exception on first invocation of expected method and then return
+values on subsequent invocations.
+
+
+
object=stub()
+object.stubs(:expected_method).raises(Exception).then.returns(2,3)
+object.expected_method# => raises exception of class Exception1
+object.expected_method# => 2
+object.expected_method# => 3
Modifies expectation so that when the expected method is called, it throws
+the specified tag with the specific return value
+object i.e. calls Kernel#throw(tag, object).
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Throw tag when expected method is invoked.
+
+
+
object=stub()
+object.stubs(:expected_method).throws(:done)
+object.expected_method# => throws tag :done
+
+
+
+
Throw tag with return value object c.f. Kernel#throw.
+
+
+
object=stub()
+object.stubs(:expected_method).throws(:done,'result')
+object.expected_method# => throws tag :done and causes catch block to return 'result'
+
+
+
+
Throw different tags on consecutive invocations of the expected method.
This factory determines what class of exception should be raised when Mocha
+detects a test failure.
+
+
This class should only be used by authors of test libraries and not by
+typical “users” of Mocha.
+
+
For example, it is used by
+Mocha::Integration::MiniTest::Adapter in order to have Mocha
+raise a MiniTest::Assertion which can then be sensibly handled
+by MiniTest::Unit::TestCase.
Determines what class of exception should be raised when Mocha detects a
+test failure.
+
+
+
+
+
+
+
+
+
+
+
+
+
Class Attribute Details
+
+
+
+
+
+
+ .exception_class ⇒ Exception
+
+
+
+
+
+
+
+
+
Determines what class of exception should be raised when Mocha detects a
+test failure.
+
+
This attribute may be set by authors of test libraries in order to have
+Mocha raise exceptions of a specific class when there is an unexpected
+invocation or an unsatisfied expectation.
+
+
By default a Mocha::ExpectationError will be raised.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Exception)
+
+
+
+ —
+
+
class of exception to be raised when an expectation error occurs
The methods in this module should be called from test libraries wishing to
+integrate with Mocha.
+
+
This module is provided as part of the Mocha::API module and
+is therefore part of the public API, but should only be used by authors of
+test libraries and not by typical “users” of Mocha.
+
+
Integration with Test::Unit and MiniTest are provided as part of Mocha,
+because they are (or were once) part of the Ruby standard library.
+Integration with other test libraries is not provided as
+part of Mocha, but is supported by means of the methods in
+this module.
+
+
See the code in the Adapter modules for examples of how to use
+the methods in this module. Mocha::ExpectationErrorFactory may
+be used if you want Mocha to raise a different type of
+exception.
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.
+
+
+
+
+
+
+
+
Examples:
+
+
+
object=mock()
+object.stubs(:expected_method).returns(1,2).then.raises(Exception)
+object.expected_method# => 1
+object.expected_method# => 2
+object.expected_method# => raises exception of class Exception1
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)
expected method name symbols as keys and corresponding return values as
+values - these expectations are setup as if #expects were called multiple
+times.
# File 'lib/mocha/mock.rb', line 329
+
+defrespond_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.
+
+ #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.
stubbed method name symbols as keys and corresponding return values as
+values - these stubbed methods are setup as if #stubs were called
+multiple times.
Adds an expectation that the specified method must be called exactly once
+with any parameters.
+
+
The original implementation of the method is replaced during the test and
+then restored at the end of the test. The temporary replacement method has
+the same visibility as the original method.
expected method name symbols as keys and corresponding return values as
+values - these expectations are setup as if #expects were called multiple
+times.
Adds an expectation that the specified method may be called any number of
+times with any parameters.
+
+
The original implementation of the method is replaced during the test and
+then restored at the end of the test. The temporary replacement method has
+the same visibility as the original method.
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Setting up a stubbed methods on a non-mock object.
stubbed method name symbols as keys and corresponding return values as
+values - these stubbed methods are setup as if #stubs were called
+multiple times.
Removes the specified stubbed methods (added by calls to #expects or
+#stubs) and all expectations associated with them.
+
+
Restores the original behaviour of the methods before they were stubbed.
+This is normally done automatically at the end of each test, but in some
+circumstances you may want to do it before the end of the
+test.
+
+
WARNING: If you #unstub a method which still has unsatisfied
+expectations, you may be removing the only way those expectations can be
+satisfied. Use #unstub with care.
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Stubbing and unstubbing a method on a real (non-mock) object.
+
+
+
multiplier=Multiplier.new
+multiplier.double(2)# => 4
+multiplier.stubs(:double).raises# new behaviour defined
+multiplier.double(2)# => raises exception
+multiplier.unstub(:double)# original behaviour restored
+multiplier.double(2)# => 4
+
+
+
+
Unstubbing multiple methods on a real (non-mock) object.
+
+
+
multiplier.unstub(:double,:triple)
+
+# exactly equivalent to
+
+multiplier.unstub(:double)
+multiplier.unstub(:triple)
object=mock()
+object.expects(:method_1).with(all_of(includes(1),includes(3)))
+object.method_1([1,3])
+# no error raised
+
+
+
+
One of the parameter matchers does not match.
+
+
+
object=mock()
+object.expects(:method_1).with(all_of(includes(1),includes(3)))
+object.method_1([1,2])
+# error raised, because method_1 was not called with object including 1 and 3
object=mock()
+object.expects(:method_1).with(equals(2))
+object.method_1(2)
+# no error raised
+
+
+
+
Actual parameter does not equal expected parameter.
+
+
+
object=mock()
+object.expects(:method_1).with(equals(2))
+object.method_1(3)
+# error raised, because method_1 was not called with an +Object+ that equals 2
Matches a URI without regard to the ordering of parameters in the query
+string.
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Actual URI is equivalent.
+
+
+
object = mock()
+object.expects(:method_1).with(equivalent_uri('http://example.com/foo?a=1&b=2))
+object.method_1('http://example.com/foo?b=2&a=1')
+# no error raised
+
+
+
+
Actual URI is not equivalent.
+
+
+
object = mock()
+object.expects(:method_1).with(equivalent_uri('http://example.com/foo?a=1&b=2))
+object.method_1('http://example.com/foo?a=1&b=3')
+# error raised, because the query parameters were different
object=mock()
+object.expects(:method_1).with(has_entries('key_1'=>1,'key_2'=>2))
+object.method_1('key_1'=>1,'key_2'=>2,'key_3'=>3)
+# no error raised
+
+
+
+
Actual parameter does not contain all expected entries.
+
+
+
object=mock()
+object.expects(:method_1).with(has_entries('key_1'=>1,'key_2'=>2))
+object.method_1('key_1'=>1,'key_2'=>99)
+# error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
Matches Hash containing entry with key and
+value.
+
+
rubocop:disable Naming/PredicateName
+
+
+
+
+
+
+
+
Examples:
+
+
+
+
Actual parameter contains expected entry supplied as key and value.
+
+
+
object=mock()
+object.expects(:method_1).with(has_entry('key_1',1))
+object.method_1('key_1'=>1,'key_2'=>2)
+# no error raised
+
+
+
+
Actual parameter contains expected entry supplied as Hash
+entry.
+
+
+
object=mock()
+object.expects(:method_1).with(has_entry('key_1'=>1))
+object.method_1('key_1'=>1,'key_2'=>2)
+# no error raised
+
+
+
+
Actual parameter does not contain expected entry supplied as key and value.
+
+
+
object=mock()
+object.expects(:method_1).with(has_entry('key_1',1))
+object.method_1('key_1'=>2,'key_2'=>1)
+# error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
+
+
+
+
Actual parameter does not contain expected entry supplied as
+Hash entry.
+
+
+
+object=mock()
+object.expects(:method_1).with(has_entry('key_1'=>1))
+object.method_1('key_1'=>2,'key_2'=>1)
+# error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
# File 'lib/mocha/parameter_matchers/has_entry.rb', line 43
+
+defhas_entry(*options)
+ caseoptions.length
+ when1
+ caseoptions[0]
+ whenHash
+ caseoptions[0].length
+ when0
+ raiseArgumentError,'Argument has no entries.'
+ when1
+ key,value=options[0].first
+ else
+ raiseArgumentError,'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.'
+ end
+ else
+ raiseArgumentError,'Argument is not a Hash.'
+ end
+ when2
+ key,value=options
+ else
+ raiseArgumentError,'Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).'
+ end
+ HasEntry.new(key,value)
+end
Actual parameter contains entry with expected key.
+
+
+
object=mock()
+object.expects(:method_1).with(has_key('key_1'))
+object.method_1('key_1'=>1,'key_2'=>2)
+# no error raised
+
+
+
+
Actual parameter does not contain entry with expected key.
+
+
+
object=mock()
+object.expects(:method_1).with(has_key('key_1'))
+object.method_1('key_2'=>2)
+# error raised, because method_1 was not called with Hash containing key: 'key_1'
Actual parameter contains entry with expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(has_value(1))
+object.method_1('key_1'=>1,'key_2'=>2)
+# no error raised
+
+
+
+
Actual parameter does not contain entry with expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(has_value(1))
+object.method_1('key_2'=>2)
+# error raised, because method_1 was not called with Hash containing value: 1
object=mock()
+object.expects(:method_1).with(instance_of(String))
+object.method_1('string')
+# no error raised
+
+
+
+
Actual parameter is not an instance of String.
+
+
+
object=mock()
+object.expects(:method_1).with(instance_of(String))
+object.method_1(99)
+# error raised, because method_1 was not called with an instance of String
object=mock()
+object.expects(:method_1).with(is_a(Integer))
+object.method_1(99)
+# no error raised
+
+
+
+
Actual parameter is not a Integer.
+
+
+
object=mock()
+object.expects(:method_1).with(is_a(Integer))
+object.method_1('string')
+# error raised, because method_1 was not called with an Integer
object=mock()
+object.expects(:method_1).with(kind_of(Integer))
+object.method_1(99)
+# no error raised
+
+
+
+
Actual parameter is not a kind of Integer.
+
+
+
object=mock()
+object.expects(:method_1).with(kind_of(Integer))
+object.method_1('string')
+# error raised, because method_1 was not called with a kind of Integer
object=mock()
+object.expects(:method_1).with(Not(includes(1)))
+object.method_1([0,2,3])
+# no error raised
+
+
+
+
Actual parameter does include the value 1.
+
+
+
object=mock()
+object.expects(:method_1).with(Not(includes(1)))
+object.method_1([0,1,2,3])
+# error raised, because method_1 was not called with object not including 1
Only the two required parameters are supplied and they both match their
+expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(1,2,optionally(3,4))
+object.method_1(1,2)
+# no error raised
+
+
+
+
Both required parameters and one of the optional parameters are supplied
+and they all match their expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(1,2,optionally(3,4))
+object.method_1(1,2,3)
+# no error raised
+
+
+
+
Both required parameters and both of the optional parameters are supplied
+and they all match their expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(1,2,optionally(3,4))
+object.method_1(1,2,3,4)
+# no error raised
+
+
+
+
One of the actual optional parameters does not match the expected value.
+
+
+
object=mock()
+object.expects(:method_1).with(1,2,optionally(3,4))
+object.method_1(1,2,3,5)
+# error raised, because optional parameters did not match
Actual parameter is matched by specified regular expression.
+
+
+
object=mock()
+object.expects(:method_1).with(regexp_matches(/e/))
+object.method_1('hello')
+# no error raised
+
+
+
+
Actual parameter is not matched by specified regular expression.
+
+
+
object=mock()
+object.expects(:method_1).with(regexp_matches(/a/))
+object.method_1('hello')
+# error raised, because method_1 was not called with a parameter that matched the
+# regular expression
Actual parameter is not YAML equivalent of specified object.
+
+
+
object=mock()
+object.expects(:method_1).with(yaml_equivalent(1,2,3))
+object.method_1("--- \n- 1\n- 2\n")
+# error raised, because method_1 was not called with YAML representing the specified Array
Subclass and implement #matches? and
+#mocha_inspect to define a custom matcher. Also add a suitably
+named instance method to Mocha::ParameterMatchers to build an instance of the
+new matcher c.f. #equals.
state which, when activated, will change the Mocha::StateMachine into the state
+with the specified state_name.
+
+
+
+
+
+
+
+
+
+
+
+
+82
+83
+84
+
+
+
# File 'lib/mocha/state_machine.rb', line 82
+
+defis(state_name)
+ State.new(self,state_name)
+end
+
+
+
+
+
+
+
+
+ #is_not(state_name) ⇒ Object
+
+
+
+
+
+
+
+
+
Provides a mechanism to determine whether the Mocha::StateMachine is not in the
+state specified by state_name at some point in the future.
+rubocop:disable Naming/PredicateName
+
+
+
+
+
+
+
+
+
+
+
+
+
+88
+89
+90
+
+
+
# File 'lib/mocha/state_machine.rb', line 88
+
+defis_not(state_name)
+ StatePredicate.new(self,state_name)
+end
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/file.README.html b/doc/file.README.html
new file mode 100644
index 000000000..8a2c77fae
--- /dev/null
+++ b/doc/file.README.html
@@ -0,0 +1,419 @@
+
+
+
+
+
+
+ File: README
+
+ — Mocha 1.7.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
If you're using Bundler, include Mocha in the Gemfile and then setup Mocha later once you know the test library has been loaded...
+
+
Test::Unit
+
+
# Gemfile
+gem"mocha"
+
+# Elsewhere after Bundler has loaded gems e.g. after `require 'bundler/setup'`
+require"test/unit"
+require"mocha/test_unit"
+
+
+
MiniTest
+
+
# Gemfile
+gem"mocha"
+
+# Elsewhere after Bundler has loaded gems e.g. after `require 'bundler/setup'`
+require"minitest/unit"
+require"mocha/minitest"
+
+
+
Rails
+
+
If you're loading Mocha using Bundler within a Rails application, you should setup Mocha manually e.g. at the bottom of your test_helper.rb.
+
+
MiniTest
+
+
# Gemfile in Rails app
+gem'mocha'
+
+# At bottom of test_helper.rb (or at least after `require 'rails/test_help'`)
+require'mocha/minitest'
+
+
+
RSpec
+
+
RSpec includes a mocha adapter. Just tell RSpec you want to mock with :mocha:
+
+
# Gemfile in Rails app
+gem'mocha'
+
+# Within `spec/spec_helper.rb`
+RSpec.configuredo|config|
+ config.mock_with:mocha
+end
+
+
+
Note: There is no need to use a require statement to setup Mocha; RSpec does this itself.
Note: As of version 0.9.8, the Mocha plugin is not automatically setup at plugin load time. Instead it must be manually setup e.g. at the bottom of your test_helper.rb.
+
+
MiniTest
+
+
# At bottom of test_helper.rb (or at least after `require 'rails/test_help'`)
+require'mocha/minitest'
+
+
+
Known Issues
+
+
+
In Mocha v1.2.0 there is a scenario where stubbing a class method originally defined in a module hangs the Ruby interpreter due to a bug in Ruby v2.3.1. See #272. This was fixed in Mocha v1.2.1.
+
Since v1.1.0 Mocha has used prepended modules internally for stubbing methods. There is an obscure Ruby bug in many (but not all) versions of Ruby between v2.0 & v2.3 which under certain circumstances may cause your Ruby interpreter to hang. See the Ruby bug report for more details. The bug has been fixed in Ruby v2.3.3 & v2.4.0.
+
Stubbing an aliased class method, where the original method is defined in a module that's used to extend the class doesn't work in Ruby 1.8.x. See stub_method_defined_on_module_and_aliased_test.rb for an example of this behaviour.
+
0.13.x versions cause a harmless, but annoying, deprecation warning when used with Rails 3.2.0-3.2.12, 3.1.0-3.1.10 & 3.0.0-3.0.19.
+
0.11.x versions don't work with Rails 3.2.13 (TypeError: superclass mismatch for class ExpectationError). See #115.
+
Versions 0.10.2, 0.10.3 & 0.11.0 of the Mocha gem were broken. Please do not use these versions.
+
Versions 0.9.6 & 0.9.7 of the Mocha Rails plugin were broken. Please do not use these versions.
classEnterprise
+ definitialize(dilithium)
+ @dilithium=dilithium
+ end
+
+ defgo(warp_factor)
+ warp_factor.times{@dilithium.nuke(:anti_matter)}
+ end
+end
+
+require'test/unit'
+require'mocha/test_unit'
+
+classEnterpriseTest<Test::Unit::TestCase
+ deftest_should_boldly_go
+ dilithium=mock()
+ dilithium.expects(:nuke).with(:anti_matter).at_least_once# auto-verified at end of test
+enterprise=Enterprise.new(dilithium)
+ enterprise.go(2)
+ end
+end
+
+
+
Partial Mocking
+
+
classOrder
+ attr_accessor:shipped_on
+
+ deftotal_cost
+ line_items.inject(0){|total,line_item|total+line_item.price}+shipping_cost
+ end
+
+ deftotal_weight
+ line_items.inject(0){|total,line_item|total+line_item.weight}
+ end
+
+ defshipping_cost
+ total_weight*5+10
+ end
+
+ class<<self
+ deffind_all
+ # Database.connection.execute('select * from orders...
+end
+
+ defnumber_shipped_since(date)
+ find_all.select{|order|order.shipped_on>date}.length
+ end
+
+ defunshipped_value
+ find_all.inject(0){|total,order|order.shipped_on?total:total+order.total_cost}
+ end
+ end
+end
+
+require'test/unit'
+require'mocha/test_unit'
+
+classOrderTest<Test::Unit::TestCase
+ # illustrates stubbing instance method
+deftest_should_calculate_shipping_cost_based_on_total_weight
+ order=Order.new
+ order.stubs(:total_weight).returns(10)
+ assert_equal60,order.shipping_cost
+ end
+
+ # illustrates stubbing class method
+deftest_should_count_number_of_orders_shipped_after_specified_date
+ now=Time.now;week_in_secs=7*24*60*60
+ order_1=Order.new;order_1.shipped_on=now-1*week_in_secs
+ order_2=Order.new;order_2.shipped_on=now-3*week_in_secs
+ Order.stubs(:find_all).returns([order_1,order_2])
+ assert_equal1,Order.number_shipped_since(now-2*week_in_secs)
+ end
+
+ # illustrates stubbing instance method for all instances of a class
+deftest_should_calculate_value_of_unshipped_orders
+ Order.stubs(:find_all).returns([Order.new,Order.new,Order.new])
+ Order.any_instance.stubs(:shipped_on).returns(nil)
+ Order.any_instance.stubs(:total_cost).returns(10)
+ assert_equal30,Order.unshipped_value
+ end
+end
+
+
+
Thread safety
+
+
Mocha is currently not thread-safe. There are two main reasons for this: (a) in multi-threaded code Mocha exceptions may be raised in a thread other than the one which is running the test and thus a Mocha exception may not be correctly intercepted by Mocha exception handling code; and (b) partial mocking changes the state of objects in the ObjectSpace which is shared across all threads in the Ruby process and this access to what is effectively global state is not synchronized.
+
+
Expectation matching / invocation order
+
+
Stubs and expectations are basically the same thing. A stub is just an expectation of zero or more invocations. The Expectation#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.
+
+
See the documentation for Mocha::Mock for further details.
+
+
Configuration
+
+
If you want, Mocha can generate a warning or raise an exception when:
+
+
+
stubbing a method unnecessarily
+
stubbing method on a non-mock object
+
stubbing a non-existent method
+
stubbing a non-public method
+
+
+
See the documentation for Mocha::Configuration for further details.
Use do ... end instead of { ... } in acceptance tests - thanks to @chrisroos (#294)
+
+
+
1.2.1
+
+
+
Fixed #272. Workaround Ruby bug 12832 which caused interpreter to hang. See https://bugs.ruby-lang.org/issues/12832. Thanks to @chrisroos & @petems (6f1c8b9b, #273).
+
+
+
1.2.0
+
+
+
Always use prepended module to stub class & instance methods for Ruby v2+ - thanks to @grosser & @chrisroos (43d56671, #244)
+
Always use prepended module to stub AnyInstance methods in Ruby v2+ - thanks to @chrisroos (#262)
+
Always set visibility of stub method to match stubbed method on included module - thanks to @grosser & @chrisroos (e87c03b0, #248)
+
Always set visibility to stub method to match stubbed method on superclass - thanks to @chrisroos (38d902ad)
+
Allow stubbing of method to which any instance responds (#200)
+
Allow includes matcher to take matcher arguments - thanks to @lazyatom (#217)
+
Avoid exception in older version of Rubygems - thanks to @chrisroos (78d930a7)
+
Add licenses to gemspec as requested by @coreyhaines (#201)
+
Fix typo in README - thanks to @jaredbeck (6119460d)
+
Added section about using Mocha with RSpec & Rails to README (#221)
+
Fix documentation for Mocha::API#stub method - thanks to @raeno (599b1dcd)
+
Added backers and sponsors from OpenCollective - thanks to @piamancini (#253)
+
Fix typo in docs for equals - thanks to @alexcoco (#254)
+
Add known issue for Ruby v1.8 to README - thanks to @chrisroos (2c642096)
+
+
+
1.1.0
+
+
+
Set visibility of any instance stub method.
+
Stub methods with a prepended method if there are other prepended methods. Thanks to @mrsimo.
+
Improve docs for Mock#responds_like & #responds_like_instance_of.
+
Use GitHub convention for instructions on contributing to Mocha.
+
Fix typos in docs. Thanks to @10io
+
+
+
1.0.0
+
+
External changes
+
+
+
Assume 'mocha' has been required when requiring 'mocha/setup'.
+
Provide shortcuts for integrating with specific test library i.e. require 'mocha/test_unit' or require 'mocha/mini_test'
+as alternatives to require 'mocha/setup'.
+
Do not automatically try to integrate with test libraries. Since the automatic test library integration functionality
+requires the test library to be loaded and this doesn't usually happen until after the bundle is loaded, it makes things
+simpler if we use require 'mocha/setup' to explicitly setup Mocha when we know the test library has been loaded. Fixes #146 & #155.
+
Consider stubs on superclasses if none exist on primary receiver. Largely based on changes suggested by @ccutrer in #145.
+Note: this may break existing tests which rely on the old behaviour. Stubbing a superclass method and then invoking that
+method on a child class would previously cause an unexpected invocation error. By searching up through the inheritance
+hierarchy for each of the delegate mock objects, we can provide more intuitive behaviour. Instead of an unexpected invocation
+error, invoking the method on the child class will cause the stubbed method on the superclass to be used.
+
Avoid recursion when constructing unexpected invocation message. Fixes #168.
+
Add explanation of method dispatch. Heavily based on the relevant jMock v1 documentation. Fixes #172.
+
Make class_eval line number more accurate. This sets the line number as the line number of the def statement. Closes #169.
+
Allow nesting of responds_with parameter matcher. Closes #166.
+
Define Mocha module before it's referenced. The test helper defines a class TestCase within the Mocha module. When
+running the tests inside the bundle, the Mocha module happens to be defined at this point. However when running the tests outside the bundle, it is not defined and so an exception is raised: uninitialized constant Mocha (NameError). Fixes #163.
+
Document lack of thread-safety. Fixes #154.
+
Document how to use the build-matrix script. Fixes #160.
+
Stubbing non-public method should use same visibility. This will probably break some existing tests that were somehow relying
+on the stubbed method being public while the original method was protected or private. Fixes #150.
+
+
+
Internal changes
+
+
+
Use lastest Rubygems in Travis CI builds.
+
Run the standard test suite against Ruby 2.1.0 in the build matrix.
+
Run integration tests against Ruby 2.0.0 with latest Test::Unit gem in the build matrix.
+
Test::Unit is not available in Ruby v1.9.3 standard library, so remove it from the build matrix.
+
Force use of Test::Unit runner, etc in relevant integration tests. Prior to this, I don't think we were really testing the
+Mocha integration with Test::Unit much, because, although TestUnitTest was a subclass of Test::Unit::TestCase, the
+important test case instances are the temporary ones built by TestRunner#run_as_test et al. Prior to this change, these
+would only have used Test::Unit where MiniTest was not available at all i.e. only in early versions of Ruby and when the
+MiniTest gem was not loaded.
+
Reset environment variables between build matrix builds.
+
Only activate integration with relevant test library for each of the integration tests.
+
Include standard build combinations from Travis CI config i.e. builds using standard library versions of test libraries.
+
Fix build-matrix.rb script. Also use .travis.yml to decide what combinations to run. This means we
+can now simulate the Travis CI build locally and avoid duplication. Fixes #157.
+
Remove Ruby version map from build matrix script. I'm using the rbenv-aliases plugin to alias minor versions to the
+relevant patch version.
+
+
+
0.14.0
+
+
+
Official support for MiniTest v5. All tests now pass on the continuous integration build.
+
+
+
0.14.0.alpha
+
+
+
Add speculative support for Minitest v5. Due to incompatibilities it has not yet been possible to run the Mocha test suite against Minitest v5. However, @zenspider (author of Minitest) provided the patch and he has tested it against Rails v4. Fixes #156. Thanks to @zenspider.
+
Documentation updates.
+
+
+
0.13.3
+
+
+
Allow Mocha::ParameterMatchers#includes to accept multiple items. Thanks to @simao.
+
Allow stubbing of privateKernel methods. Fixes #134. Thanks to @camski for reporting.
+
Avoid a warning when test/unit/version is required by other libraries in the same project. Fixes #140. Thanks to @tmiller.
+
Make auto-activation of Test::Unit integration more resilient. This change is specifically to cope with the nasty re-defining of classes that is done by the minitest-spec-rails gem. Fixes #143. Thanks to @tubaxenor for reporting.
+
Safer restoration of stubbed method visibility. Fixes #141. Thanks to @tmm1.
+
Ensure Mockery instance gets reset even if exception raised. Fixes #144.
+
Adapt Mocha acceptance tests to cope with changes in output from latest (v4.6.2) of MiniTest.
+
Updates to README about Rails compatibility.
+
+
+
0.13.2
+
+
+
Stubbing of methods re-declared with different visibilty. Fixes #109.
+
Add Mock#responds_like_instance_of. Fixes #119.
+
Make Expectation#inspect less verbose and more useful. Fixes #122.
+
Make unit tests more robust to changes in environment. Fixes #121.
+
Update README in an attempt to head Rails-related issues off at the pass.
+
Add a Gem Badge to provide a link to Mocha on Rubygems.
+
Make documentation example consistent with other examples.
+
+
+
0.13.1
+
+
+
Fix #97 - Mocha::ParameterMatchers#has_entry does not work with an Array as the entry's value. Thanks to @ngokli.
+
Allow deprecation :debug mode to be switched on from MOCHA_OPTIONS environment variable.
+
+
+
0.13.0
+
+
+
Major overhaul of MiniTest & Test::Unit integration. Mocha now integrates with later versions of the two test libraries using documented hooks rather than monkey-patching. This should mean that Mocha will integrate with new versions of either library without the need to release a new version of Mocha each time, which was clearly bad and unsustainable. Many thanks to @tenderlove, @zenspider & @kou for their help, suggestions & patience.
+
Temporarily deprecated require 'mocha'. Use require 'mocha/setup' instead. The plan is that eventually require 'mocha' will not automatically integrate with either of the two test libraries as it does at the moment, and you'll need to explicitly & separately trigger the integration. I think this will provide a lot more flexibility and will hopefully do away with the need for the require: false option in the Gemfile which has always confused people.
+
Deprecated require 'mocha_standalone' and require 'mocha/standalone'. Use require 'mocha/api instead.
+
Although these are not part of Mocha's public API, I thought I should mention that the MiniTest and Test::Unit assertion counter classes have been combined into a single class Mocha::Integration::AssertionCounter.
+
Extracted Mocha::Hooks module from Mocha::API and added documentation for test library authors.
+
Improvements to documentation. Much of it has been combined into the README file.
+
Fix #101 - Mock#respond_to? doesn't work with a string argument - thanks to @urbanautomaton.
+
Fix #105 - Travis link in README - thanks to @cknadler.
+
Various improvements to automated testing of integration with test libraries.
+
Make deprecation warnings more prominent.
+
+
+
0.12.7
+
+
+
Officially support minitest v4.1.0 (still monkey-patching).
+
+
+
0.12.6
+
+
+
Fixes #103.
+
+
+
0.12.5
+
+
+
Officially support minitest v3.5.0 (still monkey-patching).
+
+
+
0.12.4
+
+
+
Officially support minitest v3.4.0 & test-unit v2.5.2 (still monkey-patching).
+
+
+
0.12.3
+
+
+
Revert rename of undocumented internal module since it turns out Rails/ActiveSupport is relying on its existence.
+
+
+
0.12.2
+
+
+
Officially support minitest v3.3.0 (still monkey-patching)
+
+
+
0.12.1
+
+
+
Deprecation warning (instead of fail fast) if neither Test::Unit nor MiniTest is loaded. Fixes #88.
+
Remove deprecated access to Mocha::Standalone.
+
Remove the deprecated file stubba.rb.
+
Officially support test-unit v2.5.1 (still monkey-patching).
+
Improve the API acceptance test.
+
+
+
0.12.0
+
+
+
Fail fast if neither Test::Unit nor MiniTest is loaded. Fixes #40.
+
Officially support MiniTest up to v3.2.0 (still monkey-patching).
+
Officially support test-unit v2.5.0 (still monkey-patching).
+
Do not monkey-patch Test::Unit or MiniTest unless we know it's ok.
+
Add acceptance tests to demonstrate using a block as a custom parameter matcher.
+
Update Travis CI build status image to use the new build under the freerange account.
Fix for #78 i.e. alias Object#method as Object#method, not Object#method_ which already exists as another Ruby method.
+
+
+
0.11.2
+
+
+
Rails has a Request class which defines its own #method method. This broke the new mechanism for stubbing a method. This release includes a slightly modified version of fix #77 provided by @sikachu. See https://github.com/rails/rails/pull/5907 for further info.
+
+
+
0.11.1
+
+
+
In Ruby 1.8.7 methods accepting a block parameter were incorrectly restored without the block parameter after being stubbed. Fix for #76.
+
+
+
0.11.0
+
+
+
Store original method when stubbing rather than using alias_method. This fixes #41, #47, #74 and all tests now pass on both Ruby 1.8.7 and 1.9.3.
+
Attempting to stub a method on a frozen object should fail fast. See #68.
+
Prevent stubbing a method on nil by default. See #68.
+
Generate documentation using YARD instead of Rdoc - removes dependency on Coderay.
+
Publish documentation on Github pages instead of Rubyforge - uses rake task written by @tomafro.
+
Remove agiledox which has outlived it's usefulness.
+
Removed trailing whitespace throughout codebase.
+
Add documentation for Mock#unstub.
+
Improve documentation for ObjectMethods.
+
Provide a way to run multiple tests within a single acceptance test method.
+
+
+
0.10.5
+
+
+
Fix for issue #66 (hopefully without regressing on issue #63) - Mocha::Mock has Mocha::Mockery as a dependency. Stop trying to pretend otherwise. Thanks to @kennyj for reporting.
+
Fix a bunch of warnings in Ruby 1.9. There are still the 6 test failures mentioned in issue #41 which I suspect are due to the introspection gem not being Ruby 1.9-compatible.
+
Add links to README for source code & issue tracker.
+
Fix for issue #67 - Make the travis-ci badge visible in the README. Thanks to Diego Plentz for pull request.
+
Fix for issue #70 - Rename Mock#expectations to Mock#expectations to avoid conflicts. Thanks to Jeremy Stephens for pull request.
+
+
+
0.10.4
+
+
+
Fix for issue #65 - expectations not being verified in subsequent tests.
+
Fix for issue #63 - require Mocha::Mockery at Mocha::Mock class load time and not on invocation of Mock#method_missing.
+
Fix for issue #45 - raise ArgumentError if Mocha::ParameterMatchers#has_entry is given
+Hash with wrong number of entries.
+
Make global variable name more obscure to avoid clashes with other libraries.
+
Move travis-ci-related gemfiles into their own directory.
+
+
+
0.10.3
+
+
+
Fix for issue #57. Gem::Requirement#=~ was only added in rubygems v1.8.0, but Object#=~ means the result of various monkey-patching checks is always false/nil for earlier versions of rubygems. However, the method it aliases #satisfied_by? has existed since Gem::Dependency was extracted from Gem::Version in rubygems v0.9.4.4, so it's much safer to use that. Thanks to fguillen for reporting and helping with diagnosis.
+
+
+
0.10.2
+
+
+
Merge pull request #53. Unstubbing a method should not remove expectations for other stubbed methods. Fixes #52. Thanks to saikat.
+
+
+
0.10.1
+
+
+
Merge pull request #51. Use Gem::Requirement & Gem::Version for version comparison. Fixes issue #50. Thanks to meineerde.
+
Fixed typo in rdoc for Mocha::ObjectMethods.
+
Improve README as suggested in issue #46. Explain that Mocha must be loaded after test libraries and how to achieve this using Bundler.
+
Merge pull request #43 - nobody expects the spanish inquisition! Thanks to cairo140.
+
Fix for issue #39 - improve documentation for Expectation#multiple_yields.
+
Fix for issue #38 where a subtle change in test-unit v2.3.0 had been missed - only visible in verbose mode.
+
Support for MiniTest up to v2.6.2 has been verified.
+
Add explicit development dependency on coderay for generating syntax-highlighted code examples.
+
+
+
0.10.0
+
+
+
Add Expectation#throws to allow a stubbed method to use Kernel#throw.
+
Updates for versions of Test::Unit up to and including v2.3.3 (including patch by Jens Fahnenbruck).
+
Updates for versions of MiniTest up to and including v2.5.1.
+
Since the singleton method added by Mocha masks the underlying instance method, there's no need to move it out the way and then back again. This fixes Github issue #20, because the original method is left unchanged - https://github.com/floehopper/mocha/issues/20 (thanks to Nick Lewis).
+
Handle stubbing of a singleton method, leaving the original method unchanged after the test.
+
When stubbing an instance method that was originally defined as a singleton method, the original method should still exist after the test.
+
Fixed mis-print in Mocha::ObjectMethods#unstub documentation (patch by Gleb Pomykalov).
+
Improved test coverage around stubbing of methods defined in different ways - this makes use of the newly extracted introspection gem (although this means some tests are now failing in Ruby v1.9.2).
+
Added configuration for Travis continuous integration.
+
Make the gemspec the canonical reference and stop generating it from the Rakefile.
+
Use the built-in Bundler rake tasks for packaging the gem.
+
Use the "release" rake task provided by Bundler instead of using the Rake::XForge::Release functionality.
+
Extract Object#metaclass into a new metaclass gem.
+
Run rake tasks without bundle exec.
+
Avoid deprecation warning for rdoc rake task.
+
Remove the use_test_unit_gem MOCHA_OPTION which hasn't worked since we switched to bundler - we can now run the tests specifying a different Gemfile instead.
+
Use multiple Gemfiles seems to run Travis CI builds against multiple version of test-unit & minitest.
+
+
+
0.9.12
+
+
+
Make Mocha's tests pass under Ruby 1.9.2 i.e. using MiniTest. One of the main issues was that we were not parsing stacktraces on MiniTest errors comprehensively enough.
+
Avoid 'circular require considered harmful' warning when running Mocha's tests in Ruby 1.9.2
+
Make performance tests work on Ruby 1.9.2 i.e. using MiniTest.
+
Declare rake as a development dependency with newer versions of Rubygems since it's only needed to carry out developer-related tasks.
+
+
+
0.9.11
+
+
+
Added explicit support for minitest v1.5.0 to v2.0.2.
+
Make testable by rubygems-test.
+
Update links to my blog and make other links consistent.
+
Added a URI parameter matcher that ignores the order of query parameters so that tests can be independent of undefined hash ordering (patch by Paul Battley).
Inherit Mocha::ExpectationError from Exception instead of StandardError to reduce the chances of a test passing by accident - thanks to James Sanders (jsanders) - https://github.com/floehopper/mocha/issues#issue/15
Avoid loading bits of the test-unit gem by accident. This is an attempt at a fix for the problem that James Adam reported [1]. By using 'load' instead of 'require' to detect the version of Test::Unit, we can avoid rubygems trying to load bits of the test-unit gem when it's not wanted. [1] http://floehopper.lighthouseapp.com/projects/22289-mocha/tickets/50#ticket-50-13
+
Fix exception when running rake without test-unit gem. When test-unit gem >=v2.0.0 was installed but the "use_test_unit_gem" MOCHA_OPTIONS was not specified, a "comparison of Fixnum with Hash failed" exception was being raised when running the performance tests. This was because bits of the test-unit gem were being loaded accidentally and a Hash was being incorrectly supplied to the TestRunner.run method.
+
Explicitly require rubygems for running tests via rake using test-unit gem.
+
Handle newer versions of test-unit gem (v2.0.2 to v2.0.9)
+
Handle newer versions of minitest gem (v1.4.0 to v1.6.0)
+
Added warnings about monkey-patching test-unit and minitest to aid debugging. These are enabled by including "debug" in the MOCHA_OPTIONS environment variable. This is now a comma-separated list, so that we can specify multiple options e.g. MOCHA_OPTIONS=debug,use_test_unit_gem
+
Eloy Duran (alloy) made the unit tests run on 1.9.2dev r25249.
+
Eloy Duran (alloy) also improved some MiniTest TestResult code I'd written and got the acceptance tests running on Ruby 1.9 HEAD. There are still 4 failures because for some reason the backtrace line numbers are off by one. And the minitest_test test case does not run when the whole suite is run with MiniTest. These issues still need investigation.
+
Fixed some acceptance tests to run in Ruby 1.9.2 - it's no longer possible to subvert the protection of a method by calling it via Object#send.
+
Fixed "test:performance" rake task so it runs in Ruby 1.9.2.
+
Fix test incorrectly failing under Rubinius 1.0. This test imposed too many constraints. It appears that Object#inspect legitimately calls Object#object_id in Rubinius. But we're only interested in what 'id' methods Mocha::ObjectMethods#mocha_inspect calls. By stubbing Object#inspect we can relax the constraints imposed by the test.
+
Luke Redpath (lukeredpath) added new shorthand "any" and "all" composite parameter matchers using "&" and "|". This provides an alternative syntax for expecting any or all matchers to pass, e.g. foo.expects(:bar).with(equals(1) | equals(2)).
+
Improved documentation for Expectation#raises. A number of people have suggested an extension to the API to cope with custom exceptions that have extra constructor parameters. However, since the arguments supplied to Expectation#raises are just passed on to Kernel#raise, it's possible to pass in an instance of an exception. Thus no change to the API is required, but it does seem worthwhile pointing this out in the docs.
+
Corrected RDoc example for Expectation#never thanks to Red David (reddavis).
+
Improved RDoc including a change suggested by Rohit Arondekar (rohit).
+
Updated gemspec as requested by Sam Woodard (shwoodard).
+
+
+
0.9.8
+
+
+
Fixed bug "NameError raised when using Mocha as a Rails plug-in" - http://floehopper.lighthouseapp.com/projects/22289/tickets/53. Since 0.9.6 the Rails plugin has been broken. See bug report for details. You will need to explicitly load Mocha after the test framework has been loaded, e.g. by adding "require 'mocha'" at the bottom of test/test_helper.rb.
+
Make Mocha::ParameterMatchers#regexp_matches, #includes, #has_value, #has_key more robust. Thanks to Sander Hartlage.
+
Allow passing a block to Mocha::Configuration methods to only change configuration for the duration of the block. Thanks to Dan Manges.
Remove rdoc template incorporating google analytics from source control. The file just needs to exist locally and be ignored by source control. This should stop the warning showing up on e.g. RunCodeRun build results.
+
+
+
0.9.7
+
+
+
Although I had provided a deprecation warning for people using Mocha::Standalone, I had assumed people wouldn't be explicitly loading the mocha/standalone.rb file. It turns out this assumption was incorrect at least in the case of Rspec. This is now fixed.
+
+
+
0.9.6
+
+
+
Version 2.0.1 of the test-unit gem introduced a private 'run_test' method on TestCase which clashed with the public TestRunner#run_test method. So this latter method has been renamed to 'run_as_test'.
+
Stop requiring rubygems - this should be an environmental choice for the user. http://gist.github.com/54177 - describes why requiring rubygems in your library code is a bad idea.
+
It seems like overkill to vendorize coderay and meta_project when they're only needed to generate the examples for documentation and for publishing files on RubyForge. So I'm removing them and installing them locally as gems when I need them.
+
Added support for 'test-unit' gem (version >= 2.0). Note that as with other versions of Test::Unit I'm completely replacing the TestCase#run method. Unfortunately in version 2.0.0 this method differs slightly from the same method in version 2.0.1 & 2.0.2, so we have to provide different implementations to ensure that the internal working of Test::Unit are not compromised by Mocha. Note also that unless the 'test-unit' gem is loaded, requiring 'test/unit' leads to a mixture of stdlib and gem classes being loaded causing errors. To avoid a dependency on rubygems, the gem is loaded only if MOCHA_OPTIONS is set to 'use_test_unit_gem' - this option is only intended for use in running Mocha's own tests. It might be worthwhile to create a shim gem like minitest_tu_shim to allow the test-unit gem to completely replace the stdlib, but that's a job for another day. The changes in the Rakefile are to make the default task run with the 'test-unit' gem (version >= 2.0).
+
Renamed Mocha::Standalone to Mocha::API to better reflect its purpose. Added a deprecation warning for those who are referencing Mocha::Standalone.
+
Fix exception raised by HasEntry#matches? if first param is not a Hash (thanks to Taylor Barstow).
+
Ken Collins reported [1] that Mocha is always loading MiniTest if it is available and loading it causes some Rails/ActionPack tests to break. I've removed the loading of MiniTest, but this now means the user has to ensure that if they want to use MiniTest in conjunction with Mocha, he must load MiniTest before loading Mocha. [1] http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2060
+
Implemented Bacon integration (thanks to Ubiratan Pires Alberton), but this was then removed after deciding only to maintain integration with Test::Unit and MiniTest which are both Ruby standard libraries. See mailing list for details.
+
Don't monkey-patch MiniTest if it's already been monkey-patched by Mocha.
Chad Humphries pointed out that in Ruby 1.9.1, if you are not using Test::Unit or MiniTest, Mocha will attempt to load and monkey-patch Test::Unit. Mocha will now only monkey-patch Test::Unit and/or MiniTest if they have already been loaded. MiniTest tests will now run in both Ruby 1.8.6 (with MiniTest gem) and in Ruby 1.9.1 (with MiniTest std lib). See Ligthouse ticket - http://floehopper.lighthouseapp.com/projects/22289/tickets/49.
+
Made Mocha compatible with minitest 1.4.0 and above (thanks to Denis Defreyne).
+
+
+
0.9.5
+
+
+
Fixed Lighthouse bug #32 - stub_everything should mean mock responds to anything.
+
Added Expectation#twice to improve readability. Thanks to pull request from Celestino Gomes.
+
In Ruby 1.9.1, requiring 'test/unit' loads a thin wrapper around MiniTest and Test::Unit::TestCase ends up inheriting from MiniTest::Unit::TestCase. So we need to avoid including the Mocha modules more than once to avoid nasty consequences. Thanks to Matthias Hennemeyer for help with this.
+
Ruby 1.9 includes rake, but not rake/contrib. For the moment I've moved the sshpublisher require into the only rake task that needs it, so that I can at least run the tests in Ruby 1.9. It looks like I will need to build a rake/contrib gem or similar to get this working properly - http://intertwingly.net/blog/2008/01/07/Rake-Contrib-for-1-9
+
+
+
0.9.4
+
+
+
Added mocha.gemspec file generated with Chad Woolley's new rake task, so that a floehopper-mocha gem will get built on GitHub.
+
Add rake task to update mocha.gemspec with unique version, which will cause gem to be auto-built on github
+
As Tobias Crawley correctly pointed out in feature request #23055 "stubs(with_hash) not working with existing object" [1], following the principle of least surprise, it should be possible to call ObjectMethods#expects & ObjectMethods#stubs with a Hash of method_names vs return_values like you can with Mock#expects & Mock#stubs. I've also updated & improved the docs to reflect the changes. [1] http://rubyforge.org/tracker/index.php?func=detail&aid=23055&group_id=1917&atid=7480
+
Removed deprecated gem autorequire.
+
+
+
0.9.3
+
+
+
Added support for MiniTest thanks to Jeff Smick.
+
Fixed a possible bug with some of the non-default Configuration options relating to the argument to Object#respond_to?
Improved documentation to address [#22530] 'Mock methods with multiple return values not possible?'
+
respond_with parameter matcher was not available in tests.
+
Patch [#22630] Fix for a bug in running Rails tests with Ruby 1.8.7. Array#flatten was being called which in turn was checking whether each element responded to #to_ary. This check was using the two parameter version of #respond_to?, but Mock was only defining a one parameter version.
+
+
+
0.9.1
+
+
+
Fixed bug #21465 - expects & stubs should support method names as strings (as well as symbols) or fail fast. Convert all expectation method names to a symbol in case they were supplied as a string.
+
By removing Mock#unexpected_method_called we reduce the number of methods vulnerable to the problem that surfaced in bug #21563.
+
Fix bug #21563 - stubbing 'verified?' method is unsafe. Instance method names on the Mock class should be more obscure.
+
Performance improvement. StubbaExampleTest goes twice as fast on my local machine.
+
Added primitive performance test to default rake task.
+
Fix format of case statements which don't work in Ruby 1.9 and make others consistent.
+
There is no point in running (potentially expensive) checks if configuration is set to allow such checks to fail. This is a relatively quick fix in response to Chris McGrath's performance problems.
+
Fix for bug #21161 - 'uninitialized constant Deprecation in stubba.rb'.
+
It's more readable to talk about 'once' and 'twice' rather than '1 time' and '2 times'.
+
Fix bug #20883 - never should raise when called to prevent follow up errors. Fail fast when there are no matching invokable expectations and handle the stub_everything case sensibly. This might not be entirely backwards compatible, but I think the benefits outweigh the risks. The most likely change is that a test that was already failing will now fail faster, which doesn't seem so awful.
+
+
+
0.9.0
+
+
+
Configurable warnings or errors
+
+
+
when a method on a non-public method is stubbed
+
when a method on a non-existent method is stubbed
+
when a method on a non-mock object is stubbed
+
when a method is stubbed unnecessarily (i.e. the stubbed method is not called during the test)
+
+
Improved error messages
+
+
+
User-friendly list of unsatisfied expectations, satisfied expectations and state machines.
+
Improved readability of cardinality description.
+
Display sensible failure message for any_instance expectations e.g. "#AnyInstance:Foo.bar - expected calls: 1, actual calls: 0"
+
+
Parameter matchers
+
+
+
New to this release
+
optionally (allows matching of optional parameters if available)
+
yaml_equivalent (allows matching of YAML that represents the specified object)
+
responds_with (tests the quack not the duck)
+
Nesting of parameter matchers is now supported.
+
+
Optional block passed into mock initializer is evaluated in the context of the new mock instance and can be used as a shortcut to set up expectations.
+
Added JMock-style sequences for constraining the order of expected invocations. See Standalone#sequence and Expectation#in_sequence.
+
Added JMock-style states for constraining the order of expected invocations. See Standalone#states, Expectation#then, Expectation#when and StateMachine.
+
Compatibility with versions of Ruby
+
+
+
Compatibility with Ruby v1.9. All test errors and warnings fixed.
+
Nasty fix so that TestCaseAdaptor works consistently with earlier versions of Test::Unit as well as more recent versions.
Make ExpectationRaiser deal with subclasses of Interrupt which seem to need a message supplied in the raise statement in Ruby 1.8.6 (but not 1.8.4 or 1.9). Not sure this is really Mocha's responsibility.
+
+
Added deprecation warning in stubba.rb which is no longer needed and will be removed.
Added Google Webmaster meta tag to rdoc template header.
+
Put Google Webmaster meta tag in the right header i.e. the one for the index page.
+
+
+
0.5.2
+
+
+
Fix bug 11885 - "never doesn't work with stub_everything" submitted by Alexander Lang. In fixing this bug, also fixed undiscoverd bug where expected & actual invocation counts were being incorrectly reported which seems to have been introduced when fixes were added for invocation dispatch (see MockedMethodDispatchAcceptanceTest).
+
Previously when an expectation did not allow more invocations, it was treated as not matching. Now we prefer matching expectations which allow more invocations, but still match expectations which cannot allow more invocations. I think this may be overcomplicating things, but let's see how it goes.
+
+
+
0.5.1
+
+
+
Fixed bug #11583 "Mocha 0.5.0 throwing unexpected warnings". Also switched on ruby warning for all rake test tasks. Fixed majority of warnings, but some left to fix.
+
+
+
0.5.0
+
+
+
Parameter Matchers - I've added a few Hamcrest-style parameter matchers which are designed to be used inside Expectation#with. The following matchers are currently available: anything(), includes(), has_key(), has_value(), has_entry(), all_of() & any_of(). More to follow soon. The idea is eventually to get rid of the nasty parameter_block option on Expectation#with.
object = mock()
+ object.expects(:method).with(has_key('key_1'))
+ object.method('key_2' => 2)
+ # verification error raised, because method was not called with Hash containing key: 'key_1'
+
+
+
Values Returned and Exceptions Raised on Consecutive Invocations - Allow multiple calls to Expectation#returns and Expectation#raises to build up a sequence of responses to invocations on the mock. Added syntactic sugar method Expectation#then to allow more readable expectations.
Yields on Consecutive Invocations - Allow multiple calls to yields on single expectation to allow yield parameters to be specified for consecutive invocations.
Multiple Yields on Single Invocation - Added Expectation#multiple_yields to allow a mocked or stubbed method to yield multiple times for a single invocation.
Invocation Dispatch - Expectations were already being matched in reverse order i.e. the most recently defined one was being found first. This is still the case, but we now stop matching an expectation when its maximum number of expected invocations is reached. c.f. JMock v1. A stub will never stop matching by default. Hopefully this means we can soon get rid of the need to pass a Proc to Expectation#returns.
Time.stubs(:now).returns(Time.parse('Mon Jan 01 00:00:00 UTC 2007'))
+ Time.now # => Mon Jan 01 00:00:00 UTC 2007
+ Time.stubs(:now).returns(Time.parse('Thu Feb 01 00:00:00 UTC 2007'))
+ Time.now # => Thu Feb 01 00:00:00 UTC 2007
+
+
+
Deprecate passing an instance of Proc to Expectation#returns.
+
Explicitly include all Rakefile dependencies in project.
+
Fixed old Stubba example.
+
Fix so that it is possible for a stubbed method to raise an Interrupt exception without a message in Ruby 1.8.6
+
Added responds_like and quacks_like.
+
Capture standard object methods before Mocha adds any.
+
Added Expectation#once method to make interface less surprising.
+
Use Rake::TestTask to run tests. Created three separate tasks to run unit, integration & acceptance tests. Split inspect_test into one file per TestCase. Deleted superfluous all_tests file.
+
Fiddled with mocha_inspect and tests to give more sensible results on x86 platform.
+
Fixed bug #7834 "infinite_range.rb makes incorrect assumption about to_f" logged by James Moore.
+
+
+
0.4.0
+
+
+
Allow naming of mocks (patch from Chris Roos).
+
Specify multiple return values for consecutive calls.
+
Improved consistency of expectation error messages.
+
Allow mocking of Object instance methods e.g. kind_of?, type.
+
Provide aliased versions of #expects and #stubs to allow mocking of these methods.
+
Added at_least, at_most, at_most_once methods to expectation.
+
Allow expects and stubs to take a hash of method and return values.
+
Eliminate warning: "instance variable @yield not initialized" (patch from Xavier Shay).
+
Restore instance methods on partial mocks (patch from Chris Roos).
+
Allow stubbing of a method with non-word characters in its name (patch from Paul Battley).
+
Removed coupling to Test::Unit.
+
Allow specified exception instance to be raised (patch from Chris Roos).
+
Make mock object_id appear in hex like normal Ruby inspect (patch from Paul Battley).
+
Fix path to object.rb in rdoc rake task (patch from Tomas Pospisek).
+
Reverse order in which expectations are matched, so that last expectation is matched first. This allows e.g. a call to #stubs to be effectively overridden by a call to #expects (patch from Tobias Lutke).
+
Stubba & SmartTestCase modules incorporated into Mocha module so only need to require 'mocha' - no longer need to require 'stubba'.
+
AutoMocha removed.
+
+
+
0.3.3
+
+
+
Quick bug fix to restore instance methods on partial mocks (for Kevin Clark).
+
+
+
0.3.2
+
+
+
Examples added.
+
+
+
0.3.1
+
+
+
Dual licensing with MIT license added.
+
+
+
0.3.0
+
+
+
Rails plugin.
+
Auto-verify for expectations on concrete classes.
+
Include each expectation verification in the test result assertion count.
+
Filter out noise from assertion backtraces.
+
Point assertion backtrace to line where failing expectation was created.
+
New yields method for expectations.
+
Create stubs which stub all method calls.
+
Mocks now respond_to? expected methods.
+
+
+
0.2.1
+
+
+
Rename MochaAcceptanceTest::Rover#move method to avoid conflict with Rake (in Ruby 1.8.4 only?)
Reorganized directory structure and extracted addition of setup and teardown methods into SmartTestCase mini-library.
+
Addition of auto-verify for Mocha (but not Stubba). This means there is more significance in the choice of expects or stubs in that any expects on a mock will automatically get verified.
If you're using Bundler, include Mocha in the Gemfile and then setup Mocha later once you know the test library has been loaded...
+
+
Test::Unit
+
+
# Gemfile
+gem"mocha"
+
+# Elsewhere after Bundler has loaded gems e.g. after `require 'bundler/setup'`
+require"test/unit"
+require"mocha/test_unit"
+
+
+
MiniTest
+
+
# Gemfile
+gem"mocha"
+
+# Elsewhere after Bundler has loaded gems e.g. after `require 'bundler/setup'`
+require"minitest/unit"
+require"mocha/minitest"
+
+
+
Rails
+
+
If you're loading Mocha using Bundler within a Rails application, you should setup Mocha manually e.g. at the bottom of your test_helper.rb.
+
+
MiniTest
+
+
# Gemfile in Rails app
+gem'mocha'
+
+# At bottom of test_helper.rb (or at least after `require 'rails/test_help'`)
+require'mocha/minitest'
+
+
+
RSpec
+
+
RSpec includes a mocha adapter. Just tell RSpec you want to mock with :mocha:
+
+
# Gemfile in Rails app
+gem'mocha'
+
+# Within `spec/spec_helper.rb`
+RSpec.configuredo|config|
+ config.mock_with:mocha
+end
+
+
+
Note: There is no need to use a require statement to setup Mocha; RSpec does this itself.
Note: As of version 0.9.8, the Mocha plugin is not automatically setup at plugin load time. Instead it must be manually setup e.g. at the bottom of your test_helper.rb.
+
+
MiniTest
+
+
# At bottom of test_helper.rb (or at least after `require 'rails/test_help'`)
+require'mocha/minitest'
+
+
+
Known Issues
+
+
+
In Mocha v1.2.0 there is a scenario where stubbing a class method originally defined in a module hangs the Ruby interpreter due to a bug in Ruby v2.3.1. See #272. This was fixed in Mocha v1.2.1.
+
Since v1.1.0 Mocha has used prepended modules internally for stubbing methods. There is an obscure Ruby bug in many (but not all) versions of Ruby between v2.0 & v2.3 which under certain circumstances may cause your Ruby interpreter to hang. See the Ruby bug report for more details. The bug has been fixed in Ruby v2.3.3 & v2.4.0.
+
Stubbing an aliased class method, where the original method is defined in a module that's used to extend the class doesn't work in Ruby 1.8.x. See stub_method_defined_on_module_and_aliased_test.rb for an example of this behaviour.
+
0.13.x versions cause a harmless, but annoying, deprecation warning when used with Rails 3.2.0-3.2.12, 3.1.0-3.1.10 & 3.0.0-3.0.19.
+
0.11.x versions don't work with Rails 3.2.13 (TypeError: superclass mismatch for class ExpectationError). See #115.
+
Versions 0.10.2, 0.10.3 & 0.11.0 of the Mocha gem were broken. Please do not use these versions.
+
Versions 0.9.6 & 0.9.7 of the Mocha Rails plugin were broken. Please do not use these versions.
classEnterprise
+ definitialize(dilithium)
+ @dilithium=dilithium
+ end
+
+ defgo(warp_factor)
+ warp_factor.times{@dilithium.nuke(:anti_matter)}
+ end
+end
+
+require'test/unit'
+require'mocha/test_unit'
+
+classEnterpriseTest<Test::Unit::TestCase
+ deftest_should_boldly_go
+ dilithium=mock()
+ dilithium.expects(:nuke).with(:anti_matter).at_least_once# auto-verified at end of test
+enterprise=Enterprise.new(dilithium)
+ enterprise.go(2)
+ end
+end
+
+
+
Partial Mocking
+
+
classOrder
+ attr_accessor:shipped_on
+
+ deftotal_cost
+ line_items.inject(0){|total,line_item|total+line_item.price}+shipping_cost
+ end
+
+ deftotal_weight
+ line_items.inject(0){|total,line_item|total+line_item.weight}
+ end
+
+ defshipping_cost
+ total_weight*5+10
+ end
+
+ class<<self
+ deffind_all
+ # Database.connection.execute('select * from orders...
+end
+
+ defnumber_shipped_since(date)
+ find_all.select{|order|order.shipped_on>date}.length
+ end
+
+ defunshipped_value
+ find_all.inject(0){|total,order|order.shipped_on?total:total+order.total_cost}
+ end
+ end
+end
+
+require'test/unit'
+require'mocha/test_unit'
+
+classOrderTest<Test::Unit::TestCase
+ # illustrates stubbing instance method
+deftest_should_calculate_shipping_cost_based_on_total_weight
+ order=Order.new
+ order.stubs(:total_weight).returns(10)
+ assert_equal60,order.shipping_cost
+ end
+
+ # illustrates stubbing class method
+deftest_should_count_number_of_orders_shipped_after_specified_date
+ now=Time.now;week_in_secs=7*24*60*60
+ order_1=Order.new;order_1.shipped_on=now-1*week_in_secs
+ order_2=Order.new;order_2.shipped_on=now-3*week_in_secs
+ Order.stubs(:find_all).returns([order_1,order_2])
+ assert_equal1,Order.number_shipped_since(now-2*week_in_secs)
+ end
+
+ # illustrates stubbing instance method for all instances of a class
+deftest_should_calculate_value_of_unshipped_orders
+ Order.stubs(:find_all).returns([Order.new,Order.new,Order.new])
+ Order.any_instance.stubs(:shipped_on).returns(nil)
+ Order.any_instance.stubs(:total_cost).returns(10)
+ assert_equal30,Order.unshipped_value
+ end
+end
+
+
+
Thread safety
+
+
Mocha is currently not thread-safe. There are two main reasons for this: (a) in multi-threaded code Mocha exceptions may be raised in a thread other than the one which is running the test and thus a Mocha exception may not be correctly intercepted by Mocha exception handling code; and (b) partial mocking changes the state of objects in the ObjectSpace which is shared across all threads in the Ruby process and this access to what is effectively global state is not synchronized.
+
+
Expectation matching / invocation order
+
+
Stubs and expectations are basically the same thing. A stub is just an expectation of zero or more invocations. The Expectation#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.
+
+
See the documentation for Mocha::Mock for further details.
+
+
Configuration
+
+
If you want, Mocha can generate a warning or raise an exception when:
+
+
+
stubbing a method unnecessarily
+
stubbing method on a non-mock object
+
stubbing a non-existent method
+
stubbing a non-public method
+
+
+
See the documentation for Mocha::Configuration for further details.
