Mock v0.7.0 documentation
A side-by-side comparison of how to accomplish some basic tasks with mock and some other popular Python mocking libraries and frameworks.
These are:
Mocking frameworks not yet represented here are MiniMock and fudge.
pMock (last release 2004 and doesn’t import in recent versions of Python) and python-mock (last release 2005) are intentionally omitted.
Note
A more up to date, and tested for all mock libraries (only the mock examples on this page can be executed as doctests) version of this comparison is maintained by Gary Bernhardt:
This comparison is by no means complete, and also may not be fully idiomatic for all the libraries represented. Please contribute corrections, missing comparisons, or comparisons for additional libraries to the mock issue tracker.
This comparison page was originally created by the Mox project and then extended for flexmock and mock by Herman Sheremetyev. Dingus examples written by Gary Bernhadt.
Note
The examples tasks here were originally created by Mox which is a mocking framework rather than a library like mock. The tasks shown naturally exemplify tasks that frameworks are good at and not the ones they make harder. In particular you can take a Mock or MagicMock object and use it in any way you want with no up-front configuration. The same is also true for Dingus.
The examples for mock here assume version 0.7.0.
>>> # mock
>>> my_mock = mock.Mock()
>>> my_mock.some_method.return_value = "calculated value"
>>> my_mock.some_attribute = "value"
>>> assertEqual("calculated value", my_mock.some_method())
>>> assertEqual("value", my_mock.some_attribute)
# Flexmock
mock = flexmock(some_method=lambda: "calculated value", some_attribute="value")
assertEqual("calculated value", mock.some_method())
assertEqual("value", mock.some_attribute)
# Mox
mock = mox.MockAnything()
mock.some_method().AndReturn("calculated value")
mock.some_attribute = "value"
mox.Replay(mock)
assertEqual("calculated value", mock.some_method())
assertEqual("value", mock.some_attribute)
# Mocker
mock = mocker.mock()
mock.some_method()
mocker.result("calculated value")
mocker.replay()
mock.some_attribute = "value"
assertEqual("calculated value", mock.some_method())
assertEqual("value", mock.some_attribute)
>>> # Dingus
>>> my_dingus = dingus.Dingus(some_attribute="value",
... some_method__returns="calculated value")
>>> assertEqual("calculated value", my_dingus.some_method())
>>> assertEqual("value", my_dingus.some_attribute)
>>> # mock
>>> my_mock = mock.Mock()
>>> my_mock.some_method.return_value = "value"
>>> assertEqual("value", my_mock.some_method())
>>> my_mock.some_method.assert_called_once_with()
# Flexmock
mock = flexmock()
mock.should_receive("some_method").and_return("value").once
assertEqual("value", mock.some_method())
# Mox
mock = mox.MockAnything()
mock.some_method().AndReturn("value")
mox.Replay(mock)
assertEqual("value", mock.some_method())
mox.Verify(mock)
# Mocker
mock = mocker.mock()
mock.some_method()
mocker.result("value")
mocker.replay()
assertEqual("value", mock.some_method())
mocker.verify()
>>> # Dingus
>>> my_dingus = dingus.Dingus(some_method__returns="value")
>>> assertEqual("value", my_dingus.some_method())
>>> assert my_dingus.some_method.calls().once()
>>> # mock
>>> SomeObject.some_method = mock.Mock(return_value='value')
>>> assertEqual("value", SomeObject.some_method())
# Flexmock
flexmock(SomeObject).should_receive("some_method").and_return('value')
assertEqual("value", mock.some_method())
# Mox
mock = mox.MockObject(SomeObject)
mock.some_method().AndReturn("value")
mox.Replay(mock)
assertEqual("value", mock.some_method())
mox.Verify(mock)
# Mocker
mock = mocker.mock(SomeObject)
mock.Get()
mocker.result("value")
mocker.replay()
assertEqual("value", mock.some_method())
mocker.verify()
>>> # Dingus
>>> object = SomeObject
>>> object.some_method = dingus.Dingus(return_value="value")
>>> assertEqual("value", object.some_method())
>>> # mock
>>> my_mock = mock.Mock(spec=SomeObject)
>>> my_mock.method1()
<mock.Mock object at 0x...>
>>> my_mock.method2()
<mock.Mock object at 0x...>
>>> assertEqual(my_mock.method_calls, [('method1',), ('method2',)])
# Flexmock
mock = flexmock(SomeObject)
mock.should_receive('method1').once.ordered.and_return('first thing')
mock.should_receive('method2').once.ordered.and_return('second thing')
# Mox
mock = mox.MockObject(SomeObject)
mock.method1().AndReturn('first thing')
mock.method2().AndReturn('second thing')
mox.Replay(mock)
mox.Verify(mock)
# Mocker
mock = mocker.mock()
with mocker.order():
mock.method1()
mocker.result('first thing')
mock.method2()
mocker.result('second thing')
mocker.replay()
mocker.verify()
>>> # Dingus
>>> my_dingus = dingus.Dingus()
>>> my_dingus.method1()
<Dingus ...>
>>> my_dingus.method2()
<Dingus ...>
>>> assertEqual(['method1', 'method2'], [call.name for call in my_dingus.calls])
>>> # mock
>>> my_mock = mock.Mock()
>>> my_mock.some_method.side_effect = SomeException("message")
>>> assertRaises(SomeException, my_mock.some_method)
# Flexmock
mock = flexmock()
mock.should_receive("some_method").and_raise(SomeException("message"))
assertRaises(SomeException, mock.some_method)
# Mox
mock = mox.MockAnything()
mock.some_method().AndRaise(SomeException("message"))
mox.Replay(mock)
assertRaises(SomeException, mock.some_method)
mox.Verify(mock)
# Mocker
mock = mocker.mock()
mock.some_method()
mocker.throw(SomeException("message"))
mocker.replay()
assertRaises(SomeException, mock.some_method)
mocker.verify()
>>> # Dingus
>>> my_dingus = dingus.Dingus()
>>> my_dingus.some_method = dingus.exception_raiser(SomeException)
>>> assertRaises(SomeException, my_dingus.some_method)
>>> # mock
>>> with mock.patch('somemodule.Someclass') as MockClass:
... MockClass.return_value = some_other_object
... assertEqual(some_other_object, somemodule.Someclass())
...
# Flexmock
flexmock(some_module.SomeClass, new_instances=some_other_object)
assertEqual(some_other_object, some_module.SomeClass())
# Mox
# (you will probably have mox.Mox() available as self.mox in a real test)
mox.Mox().StubOutWithMock(some_module, 'SomeClass', use_mock_anything=True)
some_module.SomeClass().AndReturn(some_other_object)
mox.ReplayAll()
assertEqual(some_other_object, some_module.SomeClass())
# Mocker
# (TODO)
>>> # Dingus
>>> MockClass = dingus.Dingus(return_value=some_other_object)
>>> with dingus.patch('somemodule.SomeClass', MockClass):
... assertEqual(some_other_object, somemodule.SomeClass())
...
Note
You don’t need to do any configuration to call mock.Mock() methods multiple times. Attributes like call_count, call_args_list and method_calls provide various different ways of making assertions about how the mock was used.
>>> # mock
>>> my_mock = mock.Mock()
>>> my_mock.some_method()
<mock.Mock object at 0x...>
>>> my_mock.some_method()
<mock.Mock object at 0x...>
>>> assert my_mock.some_method.call_count >= 2
# Flexmock # (verifies that the method gets called at least twice)
flexmock(some_object).should_receive('some_method').at_least.twice
# Mox
# (does not support variable number of calls, so you need to create a new entry for each explicit call)
mock = mox.MockObject(some_object)
mock.some_method(mox.IgnoreArg(), mox.IgnoreArg())
mock.some_method(mox.IgnoreArg(), mox.IgnoreArg())
mox.Replay(mock)
mox.Verify(mock)
# Mocker
# (TODO)
>>> # Dingus
>>> my_dingus = dingus.Dingus()
>>> my_dingus.some_method()
<Dingus ...>
>>> my_dingus.some_method()
<Dingus ...>
>>> assert len(my_dingus.calls('some_method')) == 2
>>> # mock
>>> my_mock = mock.Mock()
>>> method3 = my_mock.method1.return_value.method2.return_value.method3
>>> method3.return_value = 'some value'
>>> assertEqual('some value', my_mock.method1().method2().method3(1, 2))
>>> method3.assert_called_once_with(1, 2)
# Flexmock
# (intermediate method calls are automatically assigned to temporary fake objects
# and can be called with any arguments)
flexmock(some_object).should_receive(
'method1.method2.method3'
).with_args(arg1, arg2).and_return('some value')
assertEqual('some_value', some_object.method1().method2().method3(arg1, arg2))
# Mox
mock = mox.MockObject(some_object)
mock2 = mox.MockAnything()
mock3 = mox.MockAnything()
mock.method1().AndReturn(mock1)
mock2.method2().AndReturn(mock2)
mock3.method3(arg1, arg2).AndReturn('some_value')
self.mox.ReplayAll()
assertEqual("some_value", some_object.method1().method2().method3(arg1, arg2))
self.mox.VerifyAll()
# Mocker
# (TODO)
>>> # Dingus
>>> my_dingus = dingus.Dingus()
>>> method3 = my_dingus.method1.return_value.method2.return_value.method3
>>> method3.return_value = 'some value'
>>> assertEqual('some value', my_dingus.method1().method2().method3(1, 2))
>>> assert method3.calls('()', 1, 2).once()
Examples for mock and Dingus only (so far):
>>> # mock
>>> my_mock = mock.MagicMock()
>>> with my_mock:
... pass
...
>>> my_mock.__enter__.assert_called_with()
>>> my_mock.__exit__.assert_called_with(None, None, None)
>>> # Dingus (nothing special here; all dinguses are "magic mocks")
>>> my_dingus = dingus.Dingus()
>>> with my_dingus:
... pass
...
>>> assert my_dingus.__enter__.calls()
>>> assert my_dingus.__exit__.calls('()', None, None, None)
Example for mock only (so far):
>>> # mock
>>> my_mock = mock.MagicMock()
>>> with mock.patch('__builtin__.open', my_mock):
... manager = my_mock.return_value.__enter__.return_value
... manager.read.return_value = 'some data'
... with open('foo') as h:
... data = h.read()
...
>>> data
'some data'
>>> my_mock.assert_called_once_with('foo')
or:
>>> # mock
>>> with mock.patch('__builtin__.open') as my_mock:
... my_mock.return_value.__enter__ = lambda s: s
... my_mock.return_value.__exit__ = mock.Mock()
... my_mock.return_value.read.return_value = 'some data'
... with open('foo') as h:
... data = h.read()
...
>>> data
'some data'
>>> my_mock.assert_called_once_with('foo')
>>> # Dingus
>>> my_dingus = dingus.Dingus()
>>> with dingus.patch('__builtin__.open', my_dingus):
... file_ = open.return_value.__enter__.return_value
... file_.read.return_value = 'some data'
... with open('foo') as h:
... data = f.read()
...
>>> data
'some data'
>>> assert my_dingus.calls('()', 'foo').once()