[Python-checkins] cpython: unittest.mock docs: fix use of default role
georg.brandl
python-checkins at python.org
Fri Oct 31 08:01:16 CET 2014
https://hg.python.org/cpython/rev/5a687f9ee76d
changeset: 93299:5a687f9ee76d
user: Georg Brandl <georg at python.org>
date: Fri Oct 31 07:59:37 2014 +0100
summary:
unittest.mock docs: fix use of default role
files:
Doc/library/unittest.mock-examples.rst | 250 ++--
Doc/library/unittest.mock.rst | 599 ++++++------
2 files changed, 425 insertions(+), 424 deletions(-)
diff --git a/Doc/library/unittest.mock-examples.rst b/Doc/library/unittest.mock-examples.rst
--- a/Doc/library/unittest.mock-examples.rst
+++ b/Doc/library/unittest.mock-examples.rst
@@ -28,22 +28,22 @@
>>> real.method(3, 4, 5, key='value')
<MagicMock name='method()' id='...'>
-Once our mock has been used (`real.method` in this example) it has methods
+Once our mock has been used (``real.method`` in this example) it has methods
and attributes that allow you to make assertions about how it has been used.
.. note::
In most of these examples the :class:`Mock` and :class:`MagicMock` classes
- are interchangeable. As the `MagicMock` is the more capable class it makes
+ are interchangeable. As the ``MagicMock`` is the more capable class it makes
a sensible one to use by default.
Once the mock has been called its :attr:`~Mock.called` attribute is set to
-`True`. More importantly we can use the :meth:`~Mock.assert_called_with` or
+``True``. More importantly we can use the :meth:`~Mock.assert_called_with` or
:meth:`~Mock.assert_called_once_with` method to check that it was called with
the correct arguments.
-This example tests that calling `ProductionClass().method` results in a call to
-the `something` method:
+This example tests that calling ``ProductionClass().method`` results in a call to
+the ``something`` method:
>>> class ProductionClass:
... def method(self):
@@ -66,15 +66,15 @@
method (or some part of the system under test) and then check that it is used
in the correct way.
-The simple `ProductionClass` below has a `closer` method. If it is called with
-an object then it calls `close` on it.
+The simple ``ProductionClass`` below has a ``closer`` method. If it is called with
+an object then it calls ``close`` on it.
>>> class ProductionClass:
... def closer(self, something):
... something.close()
...
-So to test it we need to pass in an object with a `close` method and check
+So to test it we need to pass in an object with a ``close`` method and check
that it was called correctly.
>>> real = ProductionClass()
@@ -96,9 +96,9 @@
are created by *calling the class*. This means you access the "mock instance"
by looking at the return value of the mocked class.
-In the example below we have a function `some_function` that instantiates `Foo`
-and calls a method on it. The call to `patch` replaces the class `Foo` with a
-mock. The `Foo` instance is the result of calling the mock, so it is configured
+In the example below we have a function ``some_function`` that instantiates ``Foo``
+and calls a method on it. The call to :func:`patch` replaces the class ``Foo`` with a
+mock. The ``Foo`` instance is the result of calling the mock, so it is configured
by modifying the mock :attr:`~Mock.return_value`.
>>> def some_function():
@@ -141,13 +141,13 @@
>>> mock.mock_calls
[call.method(), call.attribute.method(10, x=53)]
-If you make an assertion about `mock_calls` and any unexpected methods
+If you make an assertion about ``mock_calls`` and any unexpected methods
have been called, then the assertion will fail. This is useful because as well
as asserting that the calls you expected have been made, you are also checking
that they were made in the right order and with no additional calls:
You use the :data:`call` object to construct lists for comparing with
-`mock_calls`:
+``mock_calls``:
>>> expected = [call.method(), call.attribute.method(10, x=53)]
>>> mock.mock_calls == expected
@@ -185,7 +185,7 @@
3
Sometimes you want to mock up a more complex situation, like for example
-`mock.connection.cursor().execute("SELECT 1")`. If we wanted this call to
+``mock.connection.cursor().execute("SELECT 1")``. If we wanted this call to
return a list, then we have to configure the result of the nested call.
We can use :data:`call` to construct the set of calls in a "chained call" like
@@ -202,7 +202,7 @@
>>> mock.mock_calls == expected
True
-It is the call to `.call_list()` that turns our call object into a list of
+It is the call to ``.call_list()`` that turns our call object into a list of
calls representing the chained calls.
@@ -223,10 +223,10 @@
Side effect functions and iterables
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-`side_effect` can also be set to a function or an iterable. The use case for
-`side_effect` as an iterable is where your mock is going to be called several
+``side_effect`` can also be set to a function or an iterable. The use case for
+``side_effect`` as an iterable is where your mock is going to be called several
times, and you want each call to return a different value. When you set
-`side_effect` to an iterable every call to the mock returns the next value
+``side_effect`` to an iterable every call to the mock returns the next value
from the iterable:
>>> mock = MagicMock(side_effect=[4, 5, 6])
@@ -239,7 +239,7 @@
For more advanced use cases, like dynamically varying the return values
-depending on what the mock is called with, `side_effect` can be a function.
+depending on what the mock is called with, ``side_effect`` can be a function.
The function will be called with the same arguments as the mock. Whatever the
function returns is what the call returns:
@@ -259,13 +259,13 @@
One problem with over use of mocking is that it couples your tests to the
implementation of your mocks rather than your real code. Suppose you have a
-class that implements `some_method`. In a test for another class, you
-provide a mock of this object that *also* provides `some_method`. If later
-you refactor the first class, so that it no longer has `some_method` - then
+class that implements ``some_method``. In a test for another class, you
+provide a mock of this object that *also* provides ``some_method``. If later
+you refactor the first class, so that it no longer has ``some_method`` - then
your tests will continue to pass even though your code is now broken!
-`Mock` allows you to provide an object as a specification for the mock,
-using the `spec` keyword argument. Accessing methods / attributes on the
+:class:`Mock` allows you to provide an object as a specification for the mock,
+using the *spec* keyword argument. Accessing methods / attributes on the
mock that don't exist on your specification object will immediately raise an
attribute error. If you change the implementation of your specification, then
tests that use that class will start failing immediately without you having to
@@ -293,7 +293,7 @@
If you want a stronger form of specification that prevents the setting
of arbitrary attributes as well as the getting of them then you can use
-`spec_set` instead of `spec`.
+*spec_set* instead of *spec*.
@@ -302,8 +302,8 @@
.. note::
- With `patch` it matters that you patch objects in the namespace where they
- are looked up. This is normally straightforward, but for a quick guide
+ With :func:`patch` it matters that you patch objects in the namespace where
+ they are looked up. This is normally straightforward, but for a quick guide
read :ref:`where to patch <where-to-patch>`.
@@ -313,15 +313,15 @@
them has to be undone after the test or the patch will persist into other
tests and cause hard to diagnose problems.
-mock provides three convenient decorators for this: `patch`, `patch.object` and
-`patch.dict`. `patch` takes a single string, of the form
-`package.module.Class.attribute` to specify the attribute you are patching. It
+mock provides three convenient decorators for this: :func:`patch`, :func:`patch.object` and
+:func:`patch.dict`. ``patch`` takes a single string, of the form
+``package.module.Class.attribute`` to specify the attribute you are patching. It
also optionally takes a value that you want the attribute (or class or
whatever) to be replaced with. 'patch.object' takes an object and the name of
the attribute you would like patched, plus optionally the value to patch it
with.
-`patch.object`:
+``patch.object``:
>>> original = SomeClass.attribute
>>> @patch.object(SomeClass, 'attribute', sentinel.attribute)
@@ -338,8 +338,8 @@
...
>>> test()
-If you are patching a module (including :mod:`builtins`) then use `patch`
-instead of `patch.object`:
+If you are patching a module (including :mod:`builtins`) then use :func:`patch`
+instead of :func:`patch.object`:
>>> mock = MagicMock(return_value=sentinel.file_handle)
>>> with patch('builtins.open', mock):
@@ -348,7 +348,7 @@
>>> mock.assert_called_with('filename', 'r')
>>> assert handle == sentinel.file_handle, "incorrect file handle returned"
-The module name can be 'dotted', in the form `package.module` if needed:
+The module name can be 'dotted', in the form ``package.module`` if needed:
>>> @patch('package.module.ClassName.attribute', sentinel.attribute)
... def test():
@@ -368,8 +368,8 @@
>>> MyTest('test_something').test_something()
>>> assert SomeClass.attribute == original
-If you want to patch with a Mock, you can use `patch` with only one argument
-(or `patch.object` with two arguments). The mock will be created for you and
+If you want to patch with a Mock, you can use :func:`patch` with only one argument
+(or :func:`patch.object` with two arguments). The mock will be created for you and
passed into the test function / method:
>>> class MyTest(unittest2.TestCase):
@@ -394,7 +394,7 @@
When you nest patch decorators the mocks are passed in to the decorated
function in the same order they applied (the normal *python* order that
decorators are applied). This means from the bottom up, so in the example
-above the mock for `test_module.ClassName2` is passed in first.
+above the mock for ``test_module.ClassName2`` is passed in first.
There is also :func:`patch.dict` for setting values in a dictionary just
during a scope and restoring the dictionary to its original state when the test
@@ -407,9 +407,9 @@
...
>>> assert foo == original
-`patch`, `patch.object` and `patch.dict` can all be used as context managers.
+``patch``, ``patch.object`` and ``patch.dict`` can all be used as context managers.
-Where you use `patch` to create a mock for you, you can get a reference to the
+Where you use :func:`patch` to create a mock for you, you can get a reference to the
mock using the "as" form of the with statement:
>>> class ProductionClass:
@@ -424,7 +424,7 @@
>>> mock_method.assert_called_with(1, 2, 3)
-As an alternative `patch`, `patch.object` and `patch.dict` can be used as
+As an alternative ``patch``, ``patch.object`` and ``patch.dict`` can be used as
class decorators. When used in this way it is the same as applying the
decorator individually to every method whose name starts with "test".
@@ -443,11 +443,11 @@
Mocking chained calls is actually straightforward with mock once you
understand the :attr:`~Mock.return_value` attribute. When a mock is called for
-the first time, or you fetch its `return_value` before it has been called, a
-new `Mock` is created.
+the first time, or you fetch its ``return_value`` before it has been called, a
+new :class:`Mock` is created.
This means that you can see how the object returned from a call to a mocked
-object has been used by interrogating the `return_value` mock:
+object has been used by interrogating the ``return_value`` mock:
>>> mock = Mock()
>>> mock().foo(a=2, b=3)
@@ -467,22 +467,22 @@
... response = self.backend.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
... # more code
-Assuming that `BackendProvider` is already well tested, how do we test
-`method()`? Specifically, we want to test that the code section `# more
-code` uses the response object in the correct way.
+Assuming that ``BackendProvider`` is already well tested, how do we test
+``method()``? Specifically, we want to test that the code section ``# more
+code`` uses the response object in the correct way.
As this chain of calls is made from an instance attribute we can monkey patch
-the `backend` attribute on a `Something` instance. In this particular case
+the ``backend`` attribute on a ``Something`` instance. In this particular case
we are only interested in the return value from the final call to
-`start_call` so we don't have much configuration to do. Let's assume the
+``start_call`` so we don't have much configuration to do. Let's assume the
object it returns is 'file-like', so we'll ensure that our response object
-uses the builtin `open` as its `spec`.
+uses the builtin :func:`open` as its ``spec``.
To do this we create a mock instance as our mock backend and create a mock
response object for it. To set the response as the return value for that final
-`start_call` we could do this:
+``start_call`` we could do this::
- `mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response`.
+ mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response
We can do that in a slightly nicer way using the :meth:`~Mock.configure_mock`
method to directly set the return value for us:
@@ -501,7 +501,7 @@
Using :attr:`~Mock.mock_calls` we can check the chained call with a single
assert. A chained call is several calls in one line of code, so there will be
-several entries in `mock_calls`. We can use :meth:`call.call_list` to create
+several entries in ``mock_calls``. We can use :meth:`call.call_list` to create
this list of calls for us:
>>> chained = call.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
@@ -512,20 +512,20 @@
Partial mocking
~~~~~~~~~~~~~~~
-In some tests I wanted to mock out a call to :func:`datetime.date.today`
+In some tests I wanted to mock out a call to :meth:`datetime.date.today`
to return a known date, but I didn't want to prevent the code under test from
-creating new date objects. Unfortunately `datetime.date` is written in C, and
-so I couldn't just monkey-patch out the static `date.today` method.
+creating new date objects. Unfortunately :class:`datetime.date` is written in C, and
+so I couldn't just monkey-patch out the static :meth:`date.today` method.
I found a simple way of doing this that involved effectively wrapping the date
class with a mock, but passing through calls to the constructor to the real
class (and returning real instances).
The :func:`patch decorator <patch>` is used here to
-mock out the `date` class in the module under test. The :attr:`side_effect`
+mock out the ``date`` class in the module under test. The :attr:`side_effect`
attribute on the mock date class is then set to a lambda function that returns
a real date. When the mock date class is called a real date will be
-constructed and returned by `side_effect`.
+constructed and returned by ``side_effect``.
>>> from datetime import date
>>> with patch('mymodule.date') as mock_date:
@@ -536,16 +536,16 @@
... assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)
...
-Note that we don't patch `datetime.date` globally, we patch `date` in the
+Note that we don't patch :class:`datetime.date` globally, we patch ``date`` in the
module that *uses* it. See :ref:`where to patch <where-to-patch>`.
-When `date.today()` is called a known date is returned, but calls to the
-`date(...)` constructor still return normal dates. Without this you can find
+When ``date.today()`` is called a known date is returned, but calls to the
+``date(...)`` constructor still return normal dates. Without this you can find
yourself having to calculate an expected result using exactly the same
algorithm as the code under test, which is a classic testing anti-pattern.
-Calls to the date constructor are recorded in the `mock_date` attributes
-(`call_count` and friends) which may also be useful for your tests.
+Calls to the date constructor are recorded in the ``mock_date`` attributes
+(``call_count`` and friends) which may also be useful for your tests.
An alternative way of dealing with mocking dates, or other builtin classes,
is discussed in `this blog entry
@@ -561,7 +561,7 @@
A generator method / function is called to return the generator object. It is
the generator object that is then iterated over. The protocol method for
iteration is :meth:`~container.__iter__`, so we can
-mock this using a `MagicMock`.
+mock this using a :class:`MagicMock`.
Here's an example class with an "iter" method implemented as a generator:
@@ -578,7 +578,7 @@
How would we mock this class, and in particular its "iter" method?
To configure the values returned from the iteration (implicit in the call to
-`list`), we need to configure the object returned by the call to `foo.iter()`.
+:class:`list`), we need to configure the object returned by the call to ``foo.iter()``.
>>> mock_foo = MagicMock()
>>> mock_foo.iter.return_value = iter([1, 2, 3])
@@ -597,10 +597,10 @@
If you want several patches in place for multiple test methods the obvious way
is to apply the patch decorators to every method. This can feel like unnecessary
-repetition. For Python 2.6 or more recent you can use `patch` (in all its
+repetition. For Python 2.6 or more recent you can use :func:`patch` (in all its
various forms) as a class decorator. This applies the patches to all test
methods on the class. A test method is identified by methods whose names start
-with `test`:
+with ``test``:
>>> @patch('mymodule.SomeClass')
... class MyTest(TestCase):
@@ -620,7 +620,7 @@
'something'
An alternative way of managing patches is to use the :ref:`start-and-stop`.
-These allow you to move the patching into your `setUp` and `tearDown` methods.
+These allow you to move the patching into your ``setUp`` and ``tearDown`` methods.
>>> class MyTest(TestCase):
... def setUp(self):
@@ -636,7 +636,7 @@
>>> MyTest('test_foo').run()
If you use this technique you must ensure that the patching is "undone" by
-calling `stop`. This can be fiddlier than you might think, because if an
+calling ``stop``. This can be fiddlier than you might think, because if an
exception is raised in the setUp then tearDown is not called.
:meth:`unittest.TestCase.addCleanup` makes this easier:
@@ -666,13 +666,13 @@
patch out methods with a mock that having to create a real function becomes a
nuisance.
-If you pass `autospec=True` to patch then it does the patching with a
+If you pass ``autospec=True`` to patch then it does the patching with a
*real* function object. This function object has the same signature as the one
it is replacing, but delegates to a mock under the hood. You still get your
mock auto-created in exactly the same way as before. What it means though, is
that if you use it to patch out an unbound method on a class the mocked
function will be turned into a bound method if it is fetched from an instance.
-It will have `self` passed in as the first argument, which is exactly what I
+It will have ``self`` passed in as the first argument, which is exactly what I
wanted:
>>> class Foo:
@@ -687,8 +687,8 @@
'foo'
>>> mock_foo.assert_called_once_with(foo)
-If we don't use `autospec=True` then the unbound method is patched out
-with a Mock instance instead, and isn't called with `self`.
+If we don't use ``autospec=True`` then the unbound method is patched out
+with a Mock instance instead, and isn't called with ``self``.
Checking multiple calls with mock
@@ -712,7 +712,7 @@
...
AssertionError: Expected to be called once. Called 2 times.
-Both `assert_called_with` and `assert_called_once_with` make assertions about
+Both ``assert_called_with`` and ``assert_called_once_with`` make assertions about
the *most recent* call. If your mock is going to be called several times, and
you want to make assertions about *all* those calls you can use
:attr:`~Mock.call_args_list`:
@@ -725,8 +725,8 @@
[call(1, 2, 3), call(4, 5, 6), call()]
The :data:`call` helper makes it easy to make assertions about these calls. You
-can build up a list of expected calls and compare it to `call_args_list`. This
-looks remarkably similar to the repr of the `call_args_list`:
+can build up a list of expected calls and compare it to ``call_args_list``. This
+looks remarkably similar to the repr of the ``call_args_list``:
>>> expected = [call(1, 2, 3), call(4, 5, 6), call()]
>>> mock.call_args_list == expected
@@ -737,7 +737,7 @@
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Another situation is rare, but can bite you, is when your mock is called with
-mutable arguments. `call_args` and `call_args_list` store *references* to the
+mutable arguments. ``call_args`` and ``call_args_list`` store *references* to the
arguments. If the arguments are mutated by the code under test then you can no
longer make assertions about what the values were when the mock was called.
@@ -752,7 +752,7 @@
frob(val)
val.clear()
-When we try to test that `grob` calls `frob` with the correct argument look
+When we try to test that ``grob`` calls ``frob`` with the correct argument look
what happens:
>>> with patch('mymodule.frob') as mock_frob:
@@ -772,8 +772,8 @@
for equality.
Here's one solution that uses the :attr:`side_effect`
-functionality. If you provide a `side_effect` function for a mock then
-`side_effect` will be called with the same args as the mock. This gives us an
+functionality. If you provide a ``side_effect`` function for a mock then
+``side_effect`` will be called with the same args as the mock. This gives us an
opportunity to copy the arguments and store them for later assertions. In this
example I'm using *another* mock to store the arguments so that I can use the
mock methods for doing the assertion. Again a helper function sets this up for
@@ -800,15 +800,15 @@
>>> new_mock.call_args
call(set([6]))
-`copy_call_args` is called with the mock that will be called. It returns a new
-mock that we do the assertion on. The `side_effect` function makes a copy of
-the args and calls our `new_mock` with the copy.
+``copy_call_args`` is called with the mock that will be called. It returns a new
+mock that we do the assertion on. The ``side_effect`` function makes a copy of
+the args and calls our ``new_mock`` with the copy.
.. note::
If your mock is only going to be used once there is an easier way of
checking arguments at the point they are called. You can simply do the
- checking inside a `side_effect` function.
+ checking inside a ``side_effect`` function.
>>> def side_effect(arg):
... assert arg == set([6])
@@ -820,8 +820,8 @@
...
AssertionError
-An alternative approach is to create a subclass of `Mock` or `MagicMock` that
-copies (using :func:`copy.deepcopy`) the arguments.
+An alternative approach is to create a subclass of :class:`Mock` or
+:class:`MagicMock` that copies (using :func:`copy.deepcopy`) the arguments.
Here's an example implementation:
>>> from copy import deepcopy
@@ -844,9 +844,9 @@
>>> c.foo
<CopyingMock name='mock.foo' id='...'>
-When you subclass `Mock` or `MagicMock` all dynamically created attributes,
-and the `return_value` will use your subclass automatically. That means all
-children of a `CopyingMock` will also have the type `CopyingMock`.
+When you subclass ``Mock`` or ``MagicMock`` all dynamically created attributes,
+and the ``return_value`` will use your subclass automatically. That means all
+children of a ``CopyingMock`` will also have the type ``CopyingMock``.
Nesting Patches
@@ -870,9 +870,9 @@
>>> MyTest('test_foo').test_foo()
>>> assert mymodule.Foo is original
-With unittest `cleanup` functions and the :ref:`start-and-stop` we can
+With unittest ``cleanup`` functions and the :ref:`start-and-stop` we can
achieve the same effect without the nested indentation. A simple helper
-method, `create_patch`, puts the patch in place and returns the created mock
+method, ``create_patch``, puts the patch in place and returns the created mock
for us:
>>> class MyTest(TestCase):
@@ -907,11 +907,11 @@
and using :data:`~Mock.side_effect` to delegate dictionary access to a real
underlying dictionary that is under our control.
-When the `__getitem__` and `__setitem__` methods of our `MagicMock` are called
-(normal dictionary access) then `side_effect` is called with the key (and in
-the case of `__setitem__` the value too). We can also control what is returned.
+When the :meth:`__getitem__` and :meth:`__setitem__` methods of our ``MagicMock`` are called
+(normal dictionary access) then ``side_effect`` is called with the key (and in
+the case of ``__setitem__`` the value too). We can also control what is returned.
-After the `MagicMock` has been used we can use attributes like
+After the ``MagicMock`` has been used we can use attributes like
:data:`~Mock.call_args_list` to assert about how the dictionary was used:
>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
@@ -927,23 +927,23 @@
.. note::
- An alternative to using `MagicMock` is to use `Mock` and *only* provide
+ An alternative to using ``MagicMock`` is to use ``Mock`` and *only* provide
the magic methods you specifically want:
>>> mock = Mock()
>>> mock.__getitem__ = Mock(side_effect=getitem)
>>> mock.__setitem__ = Mock(side_effect=setitem)
- A *third* option is to use `MagicMock` but passing in `dict` as the `spec`
- (or `spec_set`) argument so that the `MagicMock` created only has
+ A *third* option is to use ``MagicMock`` but passing in ``dict`` as the *spec*
+ (or *spec_set*) argument so that the ``MagicMock`` created only has
dictionary magic methods available:
>>> mock = MagicMock(spec_set=dict)
>>> mock.__getitem__.side_effect = getitem
>>> mock.__setitem__.side_effect = setitem
-With these side effect functions in place, the `mock` will behave like a normal
-dictionary but recording the access. It even raises a `KeyError` if you try
+With these side effect functions in place, the ``mock`` will behave like a normal
+dictionary but recording the access. It even raises a :exc:`KeyError` if you try
to access a key that doesn't exist.
>>> mock['a']
@@ -975,8 +975,8 @@
Mock subclasses and their attributes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-There are various reasons why you might want to subclass `Mock`. One reason
-might be to add helper methods. Here's a silly example:
+There are various reasons why you might want to subclass :class:`Mock`. One
+reason might be to add helper methods. Here's a silly example:
>>> class MyMock(MagicMock):
... def has_been_called(self):
@@ -991,9 +991,9 @@
>>> mymock.has_been_called()
True
-The standard behaviour for `Mock` instances is that attributes and the return
+The standard behaviour for ``Mock`` instances is that attributes and the return
value mocks are of the same type as the mock they are accessed on. This ensures
-that `Mock` attributes are `Mocks` and `MagicMock` attributes are `MagicMocks`
+that ``Mock`` attributes are ``Mocks`` and ``MagicMock`` attributes are ``MagicMocks``
[#]_. So if you're subclassing to add helper methods then they'll also be
available on the attributes and return value mock of instances of your
subclass.
@@ -1013,10 +1013,10 @@
<http://twistedmatrix.com/documents/11.0.0/api/twisted.python.components.html>`_.
Having this applied to attributes too actually causes errors.
-`Mock` (in all its flavours) uses a method called `_get_child_mock` to create
+``Mock`` (in all its flavours) uses a method called ``_get_child_mock`` to create
these "sub-mocks" for attributes and return values. You can prevent your
subclass being used for attributes by overriding this method. The signature is
-that it takes arbitrary keyword arguments (`**kwargs`) which are then passed
+that it takes arbitrary keyword arguments (``**kwargs``) which are then passed
onto the mock constructor:
>>> class Subclass(MagicMock):
@@ -1049,17 +1049,17 @@
import (store the module as a class or module attribute and only do the import
on first use).
-That aside there is a way to use `mock` to affect the results of an import.
-Importing fetches an *object* from the `sys.modules` dictionary. Note that it
+That aside there is a way to use ``mock`` to affect the results of an import.
+Importing fetches an *object* from the :data:`sys.modules` dictionary. Note that it
fetches an *object*, which need not be a module. Importing a module for the
first time results in a module object being put in `sys.modules`, so usually
when you import something you get a module back. This need not be the case
however.
This means you can use :func:`patch.dict` to *temporarily* put a mock in place
-in `sys.modules`. Any imports whilst this patch is active will fetch the mock.
+in :data:`sys.modules`. Any imports whilst this patch is active will fetch the mock.
When the patch is complete (the decorated function exits, the with statement
-body is complete or `patcher.stop()` is called) then whatever was there
+body is complete or ``patcher.stop()`` is called) then whatever was there
previously will be restored safely.
Here's an example that mocks out the 'fooble' module.
@@ -1073,10 +1073,10 @@
>>> assert 'fooble' not in sys.modules
>>> mock.blob.assert_called_once_with()
-As you can see the `import fooble` succeeds, but on exit there is no 'fooble'
-left in `sys.modules`.
+As you can see the ``import fooble`` succeeds, but on exit there is no 'fooble'
+left in :data:`sys.modules`.
-This also works for the `from module import name` form:
+This also works for the ``from module import name`` form:
>>> mock = Mock()
>>> with patch.dict('sys.modules', {'fooble': mock}):
@@ -1106,10 +1106,10 @@
doesn't allow you to track the order of calls between separate mock objects,
however we can use :attr:`~Mock.mock_calls` to achieve the same effect.
-Because mocks track calls to child mocks in `mock_calls`, and accessing an
+Because mocks track calls to child mocks in ``mock_calls``, and accessing an
arbitrary attribute of a mock creates a child mock, we can create our separate
mocks from a parent one. Calls to those child mock will then all be recorded,
-in order, in the `mock_calls` of the parent:
+in order, in the ``mock_calls`` of the parent:
>>> manager = Mock()
>>> mock_foo = manager.foo
@@ -1124,15 +1124,15 @@
[call.foo.something(), call.bar.other.thing()]
We can then assert about the calls, including the order, by comparing with
-the `mock_calls` attribute on the manager mock:
+the ``mock_calls`` attribute on the manager mock:
>>> expected_calls = [call.foo.something(), call.bar.other.thing()]
>>> manager.mock_calls == expected_calls
True
-If `patch` is creating, and putting in place, your mocks then you can attach
+If ``patch`` is creating, and putting in place, your mocks then you can attach
them to a manager mock using the :meth:`~Mock.attach_mock` method. After
-attaching calls will be recorded in `mock_calls` of the manager.
+attaching calls will be recorded in ``mock_calls`` of the manager.
>>> manager = MagicMock()
>>> with patch('mymodule.Class1') as MockClass1:
@@ -1164,12 +1164,12 @@
>>> calls = call.one().two().three().call_list()
>>> m.assert_has_calls(calls)
-Even though the chained call `m.one().two().three()` aren't the only calls that
+Even though the chained call ``m.one().two().three()`` aren't the only calls that
have been made to the mock, the assert still succeeds.
Sometimes a mock may have several calls made to it, and you are only interested
in asserting about *some* of those calls. You may not even care about the
-order. In this case you can pass `any_order=True` to `assert_has_calls`:
+order. In this case you can pass ``any_order=True`` to ``assert_has_calls``:
>>> m = MagicMock()
>>> m(1), m.two(2, 3), m.seven(7), m.fifty('50')
@@ -1191,7 +1191,7 @@
of this object then we can create a matcher that will check these attributes
for us.
-You can see in this example how a 'standard' call to `assert_called_with` isn't
+You can see in this example how a 'standard' call to ``assert_called_with`` isn't
sufficient:
>>> class Foo:
@@ -1206,7 +1206,7 @@
AssertionError: Expected: call(<__main__.Foo object at 0x...>)
Actual call: call(<__main__.Foo object at 0x...>)
-A comparison function for our `Foo` class might look something like this:
+A comparison function for our ``Foo`` class might look something like this:
>>> def compare(self, other):
... if not type(self) == type(other):
@@ -1234,11 +1234,11 @@
>>> match_foo = Matcher(compare, Foo(1, 2))
>>> mock.assert_called_with(match_foo)
-The `Matcher` is instantiated with our compare function and the `Foo` object
-we want to compare against. In `assert_called_with` the `Matcher` equality
+The ``Matcher`` is instantiated with our compare function and the ``Foo`` object
+we want to compare against. In ``assert_called_with`` the ``Matcher`` equality
method will be called, which compares the object the mock was called with
against the one we created our matcher with. If they match then
-`assert_called_with` passes, and if they don't an `AssertionError` is raised:
+``assert_called_with`` passes, and if they don't an :exc:`AssertionError` is raised:
>>> match_wrong = Matcher(compare, Foo(3, 4))
>>> mock.assert_called_with(match_wrong)
@@ -1248,7 +1248,7 @@
Called with: ((<Foo object at 0x...>,), {})
With a bit of tweaking you could have the comparison function raise the
-`AssertionError` directly and provide a more useful failure message.
+:exc:`AssertionError` directly and provide a more useful failure message.
As of version 1.5, the Python testing library `PyHamcrest
<https://pypi.python.org/pypi/PyHamcrest>`_ provides similar functionality,
diff --git a/Doc/library/unittest.mock.rst b/Doc/library/unittest.mock.rst
--- a/Doc/library/unittest.mock.rst
+++ b/Doc/library/unittest.mock.rst
@@ -13,7 +13,7 @@
replace parts of your system under test with mock objects and make assertions
about how they have been used.
-`unittest.mock` provides a core :class:`Mock` class removing the need to
+:mod:`unittest.mock` provides a core :class:`Mock` class removing the need to
create a host of stubs throughout your test suite. After performing an
action, you can make assertions about which methods / attributes were used
and arguments they were called with. You can also specify return values and
@@ -26,10 +26,10 @@
:func:`patch`.
Mock is very easy to use and is designed for use with :mod:`unittest`. Mock
-is based on the 'action -> assertion' pattern instead of `'record -> replay'`
+is based on the 'action -> assertion' pattern instead of 'record -> replay'
used by many mocking frameworks.
-There is a backport of `unittest.mock` for earlier versions of Python,
+There is a backport of :mod:`unittest.mock` for earlier versions of Python,
available as `mock on PyPI <https://pypi.python.org/pypi/mock>`_.
**Source code:** :source:`Lib/unittest/mock.py`
@@ -71,9 +71,9 @@
(5, 4, 3)
Mock has many other ways you can configure it and control its behaviour. For
-example the `spec` argument configures the mock to take its specification
+example the *spec* argument configures the mock to take its specification
from another object. Attempting to access attributes or methods on the mock
-that don't exist on the spec will fail with an `AttributeError`.
+that don't exist on the spec will fail with an :exc:`AttributeError`.
The :func:`patch` decorator / context manager makes it easy to mock classes or
objects in a module under test. The object you specify will be replaced with a
@@ -97,13 +97,13 @@
When you nest patch decorators the mocks are passed in to the decorated
function in the same order they applied (the normal *python* order that
decorators are applied). This means from the bottom up, so in the example
- above the mock for `module.ClassName1` is passed in first.
-
- With `patch` it matters that you patch objects in the namespace where they
+ above the mock for ``module.ClassName1`` is passed in first.
+
+ With :func:`patch` it matters that you patch objects in the namespace where they
are looked up. This is normally straightforward, but for a quick guide
read :ref:`where to patch <where-to-patch>`.
-As well as a decorator `patch` can be used as a context manager in a with
+As well as a decorator :func:`patch` can be used as a context manager in a with
statement:
>>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:
@@ -135,7 +135,7 @@
>>> mock.__str__.assert_called_with()
Mock allows you to assign functions (or other Mock instances) to magic methods
-and they will be called appropriately. The `MagicMock` class is just a Mock
+and they will be called appropriately. The :class:`MagicMock` class is just a Mock
variant that has all of the magic methods pre-created for you (well, all the
useful ones anyway).
@@ -149,7 +149,7 @@
For ensuring that the mock objects in your tests have the same api as the
objects they are replacing, you can use :ref:`auto-speccing <auto-speccing>`.
-Auto-speccing can be done through the `autospec` argument to patch, or the
+Auto-speccing can be done through the *autospec* argument to patch, or the
:func:`create_autospec` function. Auto-speccing creates mock objects that
have the same attributes and methods as the objects they are replacing, and
any functions and methods (including constructors) have the same call
@@ -171,9 +171,9 @@
...
TypeError: <lambda>() takes exactly 3 arguments (1 given)
-`create_autospec` can also be used on classes, where it copies the signature of
-the `__init__` method, and on callable objects where it copies the signature of
-the `__call__` method.
+:func:`create_autospec` can also be used on classes, where it copies the signature of
+the ``__init__`` method, and on callable objects where it copies the signature of
+the ``__call__`` method.
@@ -181,77 +181,77 @@
--------------
-`Mock` is a flexible mock object intended to replace the use of stubs and
+:class:`Mock` is a flexible mock object intended to replace the use of stubs and
test doubles throughout your code. Mocks are callable and create attributes as
new mocks when you access them [#]_. Accessing the same attribute will always
return the same mock. Mocks record how you use them, allowing you to make
assertions about what your code has done to them.
-:class:`MagicMock` is a subclass of `Mock` with all the magic methods
+:class:`MagicMock` is a subclass of :class:`Mock` with all the magic methods
pre-created and ready to use. There are also non-callable variants, useful
when you are mocking out objects that aren't callable:
:class:`NonCallableMock` and :class:`NonCallableMagicMock`
The :func:`patch` decorators makes it easy to temporarily replace classes
-in a particular module with a `Mock` object. By default `patch` will create
-a `MagicMock` for you. You can specify an alternative class of `Mock` using
-the `new_callable` argument to `patch`.
+in a particular module with a :class:`Mock` object. By default :func:`patch` will create
+a :class:`MagicMock` for you. You can specify an alternative class of :class:`Mock` using
+the *new_callable* argument to :func:`patch`.
.. class:: Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)
- Create a new `Mock` object. `Mock` takes several optional arguments
+ Create a new :class:`Mock` object. :class:`Mock` takes several optional arguments
that specify the behaviour of the Mock object:
- * `spec`: This can be either a list of strings or an existing object (a
+ * *spec*: This can be either a list of strings or an existing object (a
class or instance) that acts as the specification for the mock object. If
you pass in an object then a list of strings is formed by calling dir on
the object (excluding unsupported magic attributes and methods).
- Accessing any attribute not in this list will raise an `AttributeError`.
-
- If `spec` is an object (rather than a list of strings) then
+ Accessing any attribute not in this list will raise an :exc:`AttributeError`.
+
+ If *spec* is an object (rather than a list of strings) then
:attr:`~instance.__class__` returns the class of the spec object. This
- allows mocks to pass `isinstance` tests.
-
- * `spec_set`: A stricter variant of `spec`. If used, attempting to *set*
+ allows mocks to pass :func:`isinstance` tests.
+
+ * *spec_set*: A stricter variant of *spec*. If used, attempting to *set*
or get an attribute on the mock that isn't on the object passed as
- `spec_set` will raise an `AttributeError`.
-
- * `side_effect`: A function to be called whenever the Mock is called. See
+ *spec_set* will raise an :exc:`AttributeError`.
+
+ * *side_effect*: A function to be called whenever the Mock is called. See
the :attr:`~Mock.side_effect` attribute. Useful for raising exceptions or
dynamically changing return values. The function is called with the same
arguments as the mock, and unless it returns :data:`DEFAULT`, the return
value of this function is used as the return value.
- Alternatively `side_effect` can be an exception class or instance. In
+ Alternatively *side_effect* can be an exception class or instance. In
this case the exception will be raised when the mock is called.
- If `side_effect` is an iterable then each call to the mock will return
+ If *side_effect* is an iterable then each call to the mock will return
the next value from the iterable.
- A `side_effect` can be cleared by setting it to `None`.
-
- * `return_value`: The value returned when the mock is called. By default
+ A *side_effect* can be cleared by setting it to ``None``.
+
+ * *return_value*: The value returned when the mock is called. By default
this is a new Mock (created on first access). See the
:attr:`return_value` attribute.
- * `unsafe`: By default if any attribute starts with *assert* or
- *assret* will raise an `AttributeError`. Passing `unsafe=True` will allow
- access to these attributes.
+ * *unsafe*: By default if any attribute starts with *assert* or
+ *assret* will raise an :exc:`AttributeError`. Passing ``unsafe=True``
+ will allow access to these attributes.
.. versionadded:: 3.5
- * `wraps`: Item for the mock object to wrap. If `wraps` is not None then
+ * *wraps*: Item for the mock object to wrap. If *wraps* is not None then
calling the Mock will pass the call through to the wrapped object
(returning the real result). Attribute access on the mock will return a
Mock object that wraps the corresponding attribute of the wrapped
object (so attempting to access an attribute that doesn't exist will
- raise an `AttributeError`).
-
- If the mock has an explicit `return_value` set then calls are not passed
- to the wrapped object and the `return_value` is returned instead.
-
- * `name`: If the mock has a name then it will be used in the repr of the
+ raise an :exc:`AttributeError`).
+
+ If the mock has an explicit *return_value* set then calls are not passed
+ to the wrapped object and the *return_value* is returned instead.
+
+ * *name*: If the mock has a name then it will be used in the repr of the
mock. This can be useful for debugging. The name is propagated to child
mocks.
@@ -302,13 +302,13 @@
.. method:: assert_has_calls(calls, any_order=False)
assert the mock has been called with the specified calls.
- The `mock_calls` list is checked for the calls.
-
- If `any_order` is false (the default) then the calls must be
+ The :attr:`mock_calls` list is checked for the calls.
+
+ If *any_order* is false (the default) then the calls must be
sequential. There can be extra calls before or after the
specified calls.
- If `any_order` is true then the calls can be in any order, but
+ If *any_order* is true then the calls can be in any order, but
they must all appear in :attr:`mock_calls`.
>>> mock = Mock(return_value=None)
@@ -349,7 +349,7 @@
False
This can be useful where you want to make a series of assertions that
- reuse the same object. Note that `reset_mock` *doesn't* clear the
+ reuse the same object. Note that :meth:`reset_mock` *doesn't* clear the
return value, :attr:`side_effect` or any child attributes you have
set using normal assignment. Child mocks and the return value mock
(if any) are reset as well.
@@ -357,11 +357,11 @@
.. method:: mock_add_spec(spec, spec_set=False)
- Add a spec to a mock. `spec` can either be an object or a
- list of strings. Only attributes on the `spec` can be fetched as
+ Add a spec to a mock. *spec* can either be an object or a
+ list of strings. Only attributes on the *spec* can be fetched as
attributes from the mock.
- If `spec_set` is `True` then only attributes on the spec can be set.
+ If *spec_set* is true then only attributes on the spec can be set.
.. method:: attach_mock(mock, attribute)
@@ -402,14 +402,14 @@
...
KeyError
- `configure_mock` exists to make it easier to do configuration
+ :meth:`configure_mock` exists to make it easier to do configuration
after the mock has been created.
.. method:: __dir__()
- `Mock` objects limit the results of `dir(some_mock)` to useful results.
- For mocks with a `spec` this includes all the permitted attributes
+ :class:`Mock` objects limit the results of ``dir(some_mock)`` to useful results.
+ For mocks with a *spec* this includes all the permitted attributes
for the mock.
See :data:`FILTER_DIR` for what this filtering does, and how to
@@ -469,7 +469,7 @@
<Mock name='mock()()' id='...'>
>>> mock.return_value.assert_called_with()
- `return_value` can also be set in the constructor:
+ :attr:`return_value` can also be set in the constructor:
>>> mock = Mock(return_value=3)
>>> mock.return_value
@@ -499,17 +499,17 @@
...
Exception: Boom!
- Using `side_effect` to return a sequence of values:
+ Using :attr:`side_effect` to return a sequence of values:
>>> mock = Mock()
>>> mock.side_effect = [3, 2, 1]
>>> mock(), mock(), mock()
(3, 2, 1)
- The `side_effect` function is called with the same arguments as the
+ The :attr:`side_effect` function is called with the same arguments as the
mock (so it is wise for it to take arbitrary args and keyword
arguments) and whatever it returns is used as the return value for
- the call. The exception is if `side_effect` returns :data:`DEFAULT`,
+ the call. The exception is if :attr:`side_effect` returns :data:`DEFAULT`,
in which case the normal :attr:`return_value` is used.
>>> mock = Mock(return_value=3)
@@ -520,7 +520,7 @@
>>> mock()
3
- `side_effect` can be set in the constructor. Here's an example that
+ :attr:`side_effect` can be set in the constructor. Here's an example that
adds one to the value the mock is called with and returns it:
>>> side_effect = lambda value: value + 1
@@ -530,7 +530,7 @@
>>> mock(-8)
-7
- Setting `side_effect` to `None` clears it:
+ Setting :attr:`side_effect` to ``None`` clears it:
>>> m = Mock(side_effect=KeyError, return_value=3)
>>> m()
@@ -544,7 +544,7 @@
.. attribute:: call_args
- This is either `None` (if the mock hasn't been called), or the
+ This is either ``None`` (if the mock hasn't been called), or the
arguments that the mock was last called with. This will be in the
form of a tuple: the first member is any ordered arguments the mock
was called with (or an empty tuple) and the second member is any
@@ -567,7 +567,7 @@
>>> mock.call_args
call(3, 4, 5, key='fish', next='w00t!')
- `call_args`, along with members of the lists :attr:`call_args_list`,
+ :attr:`call_args`, along with members of the lists :attr:`call_args_list`,
:attr:`method_calls` and :attr:`mock_calls` are :data:`call` objects.
These are tuples, so they can be unpacked to get at the individual
arguments and make more complex assertions. See
@@ -580,7 +580,7 @@
(so the length of the list is the number of times it has been
called). Before any calls have been made it is an empty list. The
:data:`call` object can be used for conveniently constructing lists of
- calls to compare with `call_args_list`.
+ calls to compare with :attr:`call_args_list`.
>>> mock = Mock(return_value=None)
>>> mock()
@@ -592,7 +592,7 @@
>>> mock.call_args_list == expected
True
- Members of `call_args_list` are :data:`call` objects. These can be
+ Members of :attr:`call_args_list` are :data:`call` objects. These can be
unpacked as tuples to get at the individual arguments. See
:ref:`calls as tuples <calls-as-tuples>`.
@@ -610,15 +610,15 @@
>>> mock.method_calls
[call.method(), call.property.method.attribute()]
- Members of `method_calls` are :data:`call` objects. These can be
+ Members of :attr:`method_calls` are :data:`call` objects. These can be
unpacked as tuples to get at the individual arguments. See
:ref:`calls as tuples <calls-as-tuples>`.
.. attribute:: mock_calls
- `mock_calls` records *all* calls to the mock object, its methods, magic
- methods *and* return value mocks.
+ :attr:`mock_calls` records *all* calls to the mock object, its methods,
+ magic methods *and* return value mocks.
>>> mock = MagicMock()
>>> result = mock(1, 2, 3)
@@ -635,24 +635,24 @@
>>> mock.mock_calls == expected
True
- Members of `mock_calls` are :data:`call` objects. These can be
+ Members of :attr:`mock_calls` are :data:`call` objects. These can be
unpacked as tuples to get at the individual arguments. See
:ref:`calls as tuples <calls-as-tuples>`.
.. attribute:: __class__
- Normally the `__class__` attribute of an object will return its type.
- For a mock object with a `spec` `__class__` returns the spec class
- instead. This allows mock objects to pass `isinstance` tests for the
+ Normally the :attr:`__class__` attribute of an object will return its type.
+ For a mock object with a :attr:`spec`, ``__class__`` returns the spec class
+ instead. This allows mock objects to pass :func:`isinstance` tests for the
object they are replacing / masquerading as:
>>> mock = Mock(spec=3)
>>> isinstance(mock, int)
True
- `__class__` is assignable to, this allows a mock to pass an
- `isinstance` check without forcing you to use a spec:
+ :attr:`__class__` is assignable to, this allows a mock to pass an
+ :func:`isinstance` check without forcing you to use a spec:
>>> mock = Mock()
>>> mock.__class__ = dict
@@ -661,12 +661,12 @@
.. class:: NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)
- A non-callable version of `Mock`. The constructor parameters have the same
- meaning of `Mock`, with the exception of `return_value` and `side_effect`
+ A non-callable version of :class:`Mock`. The constructor parameters have the same
+ meaning of :class:`Mock`, with the exception of *return_value* and *side_effect*
which have no meaning on a non-callable mock.
-Mock objects that use a class or an instance as a `spec` or `spec_set` are able
-to pass `isinstance` tests:
+Mock objects that use a class or an instance as a :attr:`spec` or
+:attr:`spec_set` are able to pass :func:`isinstance` tests:
>>> mock = Mock(spec=SomeClass)
>>> isinstance(mock, SomeClass)
@@ -675,11 +675,11 @@
>>> isinstance(mock, SomeClass)
True
-The `Mock` classes have support for mocking magic methods. See :ref:`magic
+The :class:`Mock` classes have support for mocking magic methods. See :ref:`magic
methods <magic-methods>` for the full details.
The mock classes and the :func:`patch` decorators all take arbitrary keyword
-arguments for configuration. For the `patch` decorators the keywords are
+arguments for configuration. For the :func:`patch` decorators the keywords are
passed to the constructor of the mock being created. The keyword arguments
are for configuring attributes of the mock:
@@ -691,7 +691,7 @@
The return value and side effect of child mocks can be set in the same way,
using dotted notation. As you can't use dotted names directly in a call you
-have to create a dictionary and unpack it using `**`:
+have to create a dictionary and unpack it using ``**``:
>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock = Mock(some_attribute='eggs', **attrs)
@@ -729,10 +729,10 @@
.. class:: PropertyMock(*args, **kwargs)
A mock intended to be used as a property, or other descriptor, on a class.
- `PropertyMock` provides `__get__` and `__set__` methods so you can specify
- a return value when it is fetched.
-
- Fetching a `PropertyMock` instance from an object calls the mock, with
+ :class:`PropertyMock` provides :meth:`__get__` and :meth:`__set__` methods
+ so you can specify a return value when it is fetched.
+
+ Fetching a :class:`PropertyMock` instance from an object calls the mock, with
no args. Setting it calls the mock with the value being set.
>>> class Foo:
@@ -754,7 +754,7 @@
[call(), call(6)]
Because of the way mock attributes are stored you can't directly attach a
-`PropertyMock` to a mock object. Instead you can attach it to the mock type
+:class:`PropertyMock` to a mock object. Instead you can attach it to the mock type
object::
>>> m = MagicMock()
@@ -778,7 +778,7 @@
like :attr:`~Mock.call_args` and :attr:`~Mock.call_args_list`.
If :attr:`~Mock.side_effect` is set then it will be called after the call has
-been recorded, so if `side_effect` raises an exception the call is still
+been recorded, so if :attr:`side_effect` raises an exception the call is still
recorded.
The simplest way to make a mock raise an exception when called is to make
@@ -799,8 +799,8 @@
>>> m.mock_calls
[call(1, 2, 3), call('two', 'three', 'four')]
-If `side_effect` is a function then whatever that function returns is what
-calls to the mock return. The `side_effect` function is called with the
+If :attr:`side_effect` is a function then whatever that function returns is what
+calls to the mock return. The :attr:`side_effect` function is called with the
same arguments as the mock. This allows you to vary the return value of the
call dynamically, based on the input:
@@ -817,7 +817,7 @@
If you want the mock to still return the default return value (a new mock), or
any set return value, then there are two ways of doing this. Either return
-`mock.return_value` from inside `side_effect`, or return :data:`DEFAULT`:
+:attr:`mock.return_value` from inside :attr:`side_effect`, or return :data:`DEFAULT`:
>>> m = MagicMock()
>>> def side_effect(*args, **kwargs):
@@ -834,8 +834,8 @@
>>> m()
3
-To remove a `side_effect`, and return to the default behaviour, set the
-`side_effect` to `None`:
+To remove a :attr:`side_effect`, and return to the default behaviour, set the
+:attr:`side_effect` to ``None``:
>>> m = MagicMock(return_value=6)
>>> def side_effect(*args, **kwargs):
@@ -848,9 +848,9 @@
>>> m()
6
-The `side_effect` can also be any iterable object. Repeated calls to the mock
+The :attr:`side_effect` can also be any iterable object. Repeated calls to the mock
will return values from the iterable (until the iterable is exhausted and
-a `StopIteration` is raised):
+a :exc:`StopIteration` is raised):
>>> m = MagicMock(side_effect=[1, 2, 3])
>>> m()
@@ -887,12 +887,12 @@
Mock objects create attributes on demand. This allows them to pretend to be
objects of any type.
-You may want a mock object to return `False` to a `hasattr` call, or raise an
-`AttributeError` when an attribute is fetched. You can do this by providing
-an object as a `spec` for a mock, but that isn't always convenient.
+You may want a mock object to return ``False`` to a :func:`hasattr` call, or raise an
+:exc:`AttributeError` when an attribute is fetched. You can do this by providing
+an object as a :attr:`spec` for a mock, but that isn't always convenient.
You "block" attributes by deleting them. Once deleted, accessing an attribute
-will raise an `AttributeError`.
+will raise an :exc:`AttributeError`.
>>> mock = MagicMock()
>>> hasattr(mock, 'm')
@@ -978,7 +978,7 @@
.. [#] The only exceptions are magic methods and attributes (those that have
leading and trailing double underscores). Mock doesn't create these but
- instead raises an ``AttributeError``. This is because the interpreter
+ instead raises an :exc:`AttributeError`. This is because the interpreter
will often implicitly request these methods, and gets *very* confused to
get a new Mock object when it expects a magic method. If you need magic
method support see :ref:`magic methods <magic-methods>`.
@@ -998,53 +998,53 @@
.. note::
- `patch` is straightforward to use. The key is to do the patching in the
+ :func:`patch` is straightforward to use. The key is to do the patching in the
right namespace. See the section `where to patch`_.
.. function:: patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
- `patch` acts as a function decorator, class decorator or a context
- manager. Inside the body of the function or with statement, the `target`
- is patched with a `new` object. When the function/with statement exits
+ :func:`patch` acts as a function decorator, class decorator or a context
+ manager. Inside the body of the function or with statement, the *target*
+ is patched with a *new* object. When the function/with statement exits
the patch is undone.
- If `new` is omitted, then the target is replaced with a
- :class:`MagicMock`. If `patch` is used as a decorator and `new` is
+ If *new* is omitted, then the target is replaced with a
+ :class:`MagicMock`. If :func:`patch` is used as a decorator and *new* is
omitted, the created mock is passed in as an extra argument to the
- decorated function. If `patch` is used as a context manager the created
+ decorated function. If :func:`patch` is used as a context manager the created
mock is returned by the context manager.
- `target` should be a string in the form `'package.module.ClassName'`. The
- `target` is imported and the specified object replaced with the `new`
- object, so the `target` must be importable from the environment you are
- calling `patch` from. The target is imported when the decorated function
+ *target* should be a string in the form ``'package.module.ClassName'``. The
+ *target* is imported and the specified object replaced with the *new*
+ object, so the *target* must be importable from the environment you are
+ calling :func:`patch` from. The target is imported when the decorated function
is executed, not at decoration time.
- The `spec` and `spec_set` keyword arguments are passed to the `MagicMock`
+ The *spec* and *spec_set* keyword arguments are passed to the :class:`MagicMock`
if patch is creating one for you.
- In addition you can pass `spec=True` or `spec_set=True`, which causes
+ In addition you can pass ``spec=True`` or ``spec_set=True``, which causes
patch to pass in the object being mocked as the spec/spec_set object.
- `new_callable` allows you to specify a different class, or callable object,
- that will be called to create the `new` object. By default `MagicMock` is
+ *new_callable* allows you to specify a different class, or callable object,
+ that will be called to create the *new* object. By default :class:`MagicMock` is
used.
- A more powerful form of `spec` is `autospec`. If you set `autospec=True`
+ A more powerful form of *spec* is *autospec*. If you set ``autospec=True``
then the mock with be created with a spec from the object being replaced.
All attributes of the mock will also have the spec of the corresponding
attribute of the object being replaced. Methods and functions being mocked
- will have their arguments checked and will raise a `TypeError` if they are
+ will have their arguments checked and will raise a :exc:`TypeError` if they are
called with the wrong signature. For mocks
replacing a class, their return value (the 'instance') will have the same
spec as the class. See the :func:`create_autospec` function and
:ref:`auto-speccing`.
- Instead of `autospec=True` you can pass `autospec=some_object` to use an
+ Instead of ``autospec=True`` you can pass ``autospec=some_object`` to use an
arbitrary object as the spec instead of the one being replaced.
- By default `patch` will fail to replace attributes that don't exist. If
- you pass in `create=True`, and the attribute doesn't exist, patch will
+ By default :func:`patch` will fail to replace attributes that don't exist. If
+ you pass in ``create=True``, and the attribute doesn't exist, patch will
create the attribute for you when the patched function is called, and
delete it again afterwards. This is useful for writing tests against
attributes that your production code creates at runtime. It is off by
@@ -1055,27 +1055,27 @@
.. versionchanged:: 3.5
If you are patching builtins in a module then you don't
- need to pass `create=True`, it will be added by default.
-
- Patch can be used as a `TestCase` class decorator. It works by
+ need to pass ``create=True``, it will be added by default.
+
+ Patch can be used as a :class:`TestCase` class decorator. It works by
decorating each test method in the class. This reduces the boilerplate
- code when your test methods share a common patchings set. `patch` finds
- tests by looking for method names that start with `patch.TEST_PREFIX`.
- By default this is `test`, which matches the way `unittest` finds tests.
- You can specify an alternative prefix by setting `patch.TEST_PREFIX`.
+ code when your test methods share a common patchings set. :func:`patch` finds
+ tests by looking for method names that start with ``patch.TEST_PREFIX``.
+ By default this is ``'test'``, which matches the way :mod:`unittest` finds tests.
+ You can specify an alternative prefix by setting ``patch.TEST_PREFIX``.
Patch can be used as a context manager, with the with statement. Here the
patching applies to the indented block after the with statement. If you
use "as" then the patched object will be bound to the name after the
- "as"; very useful if `patch` is creating a mock object for you.
-
- `patch` takes arbitrary keyword arguments. These will be passed to
- the `Mock` (or `new_callable`) on construction.
-
- `patch.dict(...)`, `patch.multiple(...)` and `patch.object(...)` are
+ "as"; very useful if :func:`patch` is creating a mock object for you.
+
+ :func:`patch` takes arbitrary keyword arguments. These will be passed to
+ the :class:`Mock` (or *new_callable*) on construction.
+
+ ``patch.dict(...)``, ``patch.multiple(...)`` and ``patch.object(...)`` are
available for alternate use-cases.
-`patch` as function decorator, creating the mock for you and passing it into
+:func:`patch` as function decorator, creating the mock for you and passing it into
the decorated function:
>>> @patch('__main__.SomeClass')
@@ -1085,16 +1085,16 @@
>>> function(None)
True
-Patching a class replaces the class with a `MagicMock` *instance*. If the
+Patching a class replaces the class with a :class:`MagicMock` *instance*. If the
class is instantiated in the code under test then it will be the
:attr:`~Mock.return_value` of the mock that will be used.
If the class is instantiated multiple times you could use
:attr:`~Mock.side_effect` to return a new mock each time. Alternatively you
-can set the `return_value` to be anything you want.
+can set the *return_value* to be anything you want.
To configure return values on methods of *instances* on the patched class
-you must do this on the `return_value`. For example:
+you must do this on the :attr:`return_value`. For example:
>>> class Class:
... def method(self):
@@ -1107,7 +1107,7 @@
... assert Class().method() == 'foo'
...
-If you use `spec` or `spec_set` and `patch` is replacing a *class*, then the
+If you use *spec* or *spec_set* and :func:`patch` is replacing a *class*, then the
return value of the created mock will have the same spec.
>>> Original = Class
@@ -1117,7 +1117,7 @@
>>> assert isinstance(instance, Original)
>>> patcher.stop()
-The `new_callable` argument is useful where you want to use an alternative
+The *new_callable* argument is useful where you want to use an alternative
class to the default :class:`MagicMock` for the created mock. For example, if
you wanted a :class:`NonCallableMock` to be used:
@@ -1130,7 +1130,7 @@
...
TypeError: 'NonCallableMock' object is not callable
-Another use case might be to replace an object with a `io.StringIO` instance:
+Another use case might be to replace an object with a :class:`io.StringIO` instance:
>>> from io import StringIO
>>> def foo():
@@ -1143,7 +1143,7 @@
...
>>> test()
-When `patch` is creating a mock for you, it is common that the first thing
+When :func:`patch` is creating a mock for you, it is common that the first thing
you need to do is to configure the mock. Some of that configuration can be done
in the call to patch. Any arbitrary keywords you pass into the call will be
used to set attributes on the created mock:
@@ -1159,7 +1159,7 @@
:attr:`~Mock.return_value` and :attr:`~Mock.side_effect`, of child mocks can
also be configured. These aren't syntactically valid to pass in directly as
keyword arguments, but a dictionary with these as keys can still be expanded
-into a `patch` call using `**`:
+into a :func:`patch` call using ``**``:
>>> config = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> patcher = patch('__main__.thing', **config)
@@ -1177,19 +1177,19 @@
.. function:: patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
- patch the named member (`attribute`) on an object (`target`) with a mock
+ patch the named member (*attribute*) on an object (*target*) with a mock
object.
- `patch.object` can be used as a decorator, class decorator or a context
- manager. Arguments `new`, `spec`, `create`, `spec_set`, `autospec` and
- `new_callable` have the same meaning as for `patch`. Like `patch`,
- `patch.object` takes arbitrary keyword arguments for configuring the mock
+ :func:`patch.object` can be used as a decorator, class decorator or a context
+ manager. Arguments *new*, *spec*, *create*, *spec_set*, *autospec* and
+ *new_callable* have the same meaning as for :func:`patch`. Like :func:`patch`,
+ :func:`patch.object` takes arbitrary keyword arguments for configuring the mock
object it creates.
- When used as a class decorator `patch.object` honours `patch.TEST_PREFIX`
+ When used as a class decorator :func:`patch.object` honours ``patch.TEST_PREFIX``
for choosing which methods to wrap.
-You can either call `patch.object` with three arguments or two arguments. The
+You can either call :func:`patch.object` with three arguments or two arguments. The
three argument form takes the object to be patched, the attribute name and the
object to replace the attribute with.
@@ -1204,8 +1204,8 @@
...
>>> test()
-`spec`, `create` and the other arguments to `patch.object` have the same
-meaning as they do for `patch`.
+*spec*, *create* and the other arguments to :func:`patch.object` have the same
+meaning as they do for :func:`patch`.
patch.dict
@@ -1216,27 +1216,27 @@
Patch a dictionary, or dictionary like object, and restore the dictionary
to its original state after the test.
- `in_dict` can be a dictionary or a mapping like container. If it is a
+ *in_dict* can be a dictionary or a mapping like container. If it is a
mapping then it must at least support getting, setting and deleting items
plus iterating over keys.
- `in_dict` can also be a string specifying the name of the dictionary, which
+ *in_dict* can also be a string specifying the name of the dictionary, which
will then be fetched by importing it.
- `values` can be a dictionary of values to set in the dictionary. `values`
- can also be an iterable of `(key, value)` pairs.
-
- If `clear` is true then the dictionary will be cleared before the new
+ *values* can be a dictionary of values to set in the dictionary. *values*
+ can also be an iterable of ``(key, value)`` pairs.
+
+ If *clear* is true then the dictionary will be cleared before the new
values are set.
- `patch.dict` can also be called with arbitrary keyword arguments to set
+ :func:`patch.dict` can also be called with arbitrary keyword arguments to set
values in the dictionary.
- `patch.dict` can be used as a context manager, decorator or class
- decorator. When used as a class decorator `patch.dict` honours
- `patch.TEST_PREFIX` for choosing which methods to wrap.
-
-`patch.dict` can be used to add members to a dictionary, or simply let a test
+ :func:`patch.dict` can be used as a context manager, decorator or class
+ decorator. When used as a class decorator :func:`patch.dict` honours
+ ``patch.TEST_PREFIX`` for choosing which methods to wrap.
+
+:func:`patch.dict` can be used to add members to a dictionary, or simply let a test
change a dictionary, and ensure the dictionary is restored when the test
ends.
@@ -1253,7 +1253,7 @@
newvalue
>>> assert 'newkey' not in os.environ
-Keywords can be used in the `patch.dict` call to set values in the dictionary:
+Keywords can be used in the :func:`patch.dict` call to set values in the dictionary:
>>> mymodule = MagicMock()
>>> mymodule.function.return_value = 'fish'
@@ -1263,11 +1263,11 @@
...
'fish'
-`patch.dict` can be used with dictionary like objects that aren't actually
+:func:`patch.dict` can be used with dictionary like objects that aren't actually
dictionaries. At the very minimum they must support item getting, setting,
deleting and either iteration or membership test. This corresponds to the
-magic methods `__getitem__`, `__setitem__`, `__delitem__` and either
-`__iter__` or `__contains__`.
+magic methods :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__` and either
+:meth:`__iter__` or :meth:`__contains__`.
>>> class Container:
... def __init__(self):
@@ -1303,21 +1303,21 @@
with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):
...
- Use :data:`DEFAULT` as the value if you want `patch.multiple` to create
+ Use :data:`DEFAULT` as the value if you want :func:`patch.multiple` to create
mocks for you. In this case the created mocks are passed into a decorated
- function by keyword, and a dictionary is returned when `patch.multiple` is
+ function by keyword, and a dictionary is returned when :func:`patch.multiple` is
used as a context manager.
- `patch.multiple` can be used as a decorator, class decorator or a context
- manager. The arguments `spec`, `spec_set`, `create`, `autospec` and
- `new_callable` have the same meaning as for `patch`. These arguments will
- be applied to *all* patches done by `patch.multiple`.
-
- When used as a class decorator `patch.multiple` honours `patch.TEST_PREFIX`
+ :func:`patch.multiple` can be used as a decorator, class decorator or a context
+ manager. The arguments *spec*, *spec_set*, *create*, *autospec* and
+ *new_callable* have the same meaning as for :func:`patch`. These arguments will
+ be applied to *all* patches done by :func:`patch.multiple`.
+
+ When used as a class decorator :func:`patch.multiple` honours ``patch.TEST_PREFIX``
for choosing which methods to wrap.
-If you want `patch.multiple` to create mocks for you, then you can use
-:data:`DEFAULT` as the value. If you use `patch.multiple` as a decorator
+If you want :func:`patch.multiple` to create mocks for you, then you can use
+:data:`DEFAULT` as the value. If you use :func:`patch.multiple` as a decorator
then the created mocks are passed into the decorated function by keyword.
>>> thing = object()
@@ -1330,8 +1330,8 @@
...
>>> test_function()
-`patch.multiple` can be nested with other `patch` decorators, but put arguments
-passed by keyword *after* any of the standard arguments created by `patch`:
+:func:`patch.multiple` can be nested with other ``patch`` decorators, but put arguments
+passed by keyword *after* any of the standard arguments created by :func:`patch`:
>>> @patch('sys.exit')
... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
@@ -1342,7 +1342,7 @@
...
>>> test_function()
-If `patch.multiple` is used as a context manager, the value returned by the
+If :func:`patch.multiple` is used as a context manager, the value returned by the
context manger is a dictionary where created mocks are keyed by name:
>>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:
@@ -1358,16 +1358,16 @@
patch methods: start and stop
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-All the patchers have `start` and `stop` methods. These make it simpler to do
-patching in `setUp` methods or where you want to do multiple patches without
+All the patchers have :meth:`start` and :meth:`stop` methods. These make it simpler to do
+patching in ``setUp`` methods or where you want to do multiple patches without
nesting decorators or with statements.
-To use them call `patch`, `patch.object` or `patch.dict` as normal and keep a
-reference to the returned `patcher` object. You can then call `start` to put
-the patch in place and `stop` to undo it.
-
-If you are using `patch` to create a mock for you then it will be returned by
-the call to `patcher.start`.
+To use them call :func:`patch`, :func:`patch.object` or :func:`patch.dict` as
+normal and keep a reference to the returned ``patcher`` object. You can then
+call :meth:`start` to put the patch in place and :meth:`stop` to undo it.
+
+If you are using :func:`patch` to create a mock for you then it will be returned by
+the call to ``patcher.start``.
>>> patcher = patch('package.module.ClassName')
>>> from package import module
@@ -1380,8 +1380,8 @@
>>> assert module.ClassName is not new_mock
-A typical use case for this might be for doing multiple patches in the `setUp`
-method of a `TestCase`:
+A typical use case for this might be for doing multiple patches in the ``setUp``
+method of a :class:`TestCase`:
>>> class MyTest(TestCase):
... def setUp(self):
@@ -1403,7 +1403,7 @@
.. caution::
If you use this technique you must ensure that the patching is "undone" by
- calling `stop`. This can be fiddlier than you might think, because if an
+ calling ``stop``. This can be fiddlier than you might think, because if an
exception is raised in the ``setUp`` then ``tearDown`` is not called.
:meth:`unittest.TestCase.addCleanup` makes this easier:
@@ -1417,22 +1417,23 @@
... assert package.module.Class is self.MockClass
...
- As an added bonus you no longer need to keep a reference to the `patcher`
+ As an added bonus you no longer need to keep a reference to the ``patcher``
object.
It is also possible to stop all patches which have been started by using
-`patch.stopall`.
+:func:`patch.stopall`.
.. function:: patch.stopall
- Stop all active patches. Only stops patches started with `start`.
-
-.. patch-builtins:
+ Stop all active patches. Only stops patches started with ``start``.
+
+
+.. _patch-builtins:
patch builtins
-~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~
You can patch any builtins within a module. The following example patches
-builtin `ord`:
+builtin :func:`ord`:
>>> @patch('__main__.ord')
... def test(mock_ord):
@@ -1448,11 +1449,11 @@
All of the patchers can be used as class decorators. When used in this way
they wrap every test method on the class. The patchers recognise methods that
-start with `test` as being test methods. This is the same way that the
+start with ``'test'`` as being test methods. This is the same way that the
:class:`unittest.TestLoader` finds test methods by default.
It is possible that you want to use a different prefix for your tests. You can
-inform the patchers of the different prefix by setting `patch.TEST_PREFIX`:
+inform the patchers of the different prefix by setting ``patch.TEST_PREFIX``:
>>> patch.TEST_PREFIX = 'foo'
>>> value = 3
@@ -1505,7 +1506,7 @@
Where to patch
~~~~~~~~~~~~~~
-`patch` works by (temporarily) changing the object that a *name* points to with
+:func:`patch` works by (temporarily) changing the object that a *name* points to with
another one. There can be many names pointing to any individual object, so
for patching to work you must ensure that you patch the name used by the system
under test.
@@ -1523,23 +1524,23 @@
-> from a import SomeClass
-> some_function instantiates SomeClass
-Now we want to test `some_function` but we want to mock out `SomeClass` using
-`patch`. The problem is that when we import module b, which we will have to
-do then it imports `SomeClass` from module a. If we use `patch` to mock out
-`a.SomeClass` then it will have no effect on our test; module b already has a
-reference to the *real* `SomeClass` and it looks like our patching had no
+Now we want to test ``some_function`` but we want to mock out ``SomeClass`` using
+:func:`patch`. The problem is that when we import module b, which we will have to
+do then it imports ``SomeClass`` from module a. If we use :func:`patch` to mock out
+``a.SomeClass`` then it will have no effect on our test; module b already has a
+reference to the *real* ``SomeClass`` and it looks like our patching had no
effect.
-The key is to patch out `SomeClass` where it is used (or where it is looked up
-). In this case `some_function` will actually look up `SomeClass` in module b,
+The key is to patch out ``SomeClass`` where it is used (or where it is looked up
+). In this case ``some_function`` will actually look up ``SomeClass`` in module b,
where we have imported it. The patching should look like::
@patch('b.SomeClass')
-However, consider the alternative scenario where instead of `from a import
-SomeClass` module b does `import a` and `some_function` uses `a.SomeClass`. Both
+However, consider the alternative scenario where instead of ``from a import
+SomeClass`` module b does ``import a`` and ``some_function`` uses ``a.SomeClass``. Both
of these import forms are common. In this case the class we want to patch is
-being looked up on the a module and so we have to patch `a.SomeClass` instead::
+being looked up on the a module and so we have to patch ``a.SomeClass`` instead::
@patch('a.SomeClass')
@@ -1595,7 +1596,7 @@
[]
One use case for this is for mocking objects used as context managers in a
-`with` statement:
+:keyword:`with` statement:
>>> mock = Mock()
>>> mock.__enter__ = Mock(return_value='foo')
@@ -1611,8 +1612,8 @@
.. note::
- If you use the `spec` keyword argument to create a mock then attempting to
- set a magic method that isn't in the spec will raise an `AttributeError`.
+ If you use the *spec* keyword argument to create a mock then attempting to
+ set a magic method that isn't in the spec will raise an :exc:`AttributeError`.
The full list of supported magic methods is:
@@ -1648,7 +1649,7 @@
Magic Mock
~~~~~~~~~~
-There are two `MagicMock` variants: `MagicMock` and `NonCallableMagicMock`.
+There are two ``MagicMock`` variants: :class:`MagicMock` and :class:`NonCallableMagicMock`.
.. class:: MagicMock(*args, **kw)
@@ -1659,19 +1660,19 @@
The constructor parameters have the same meaning as for :class:`Mock`.
- If you use the `spec` or `spec_set` arguments then *only* magic methods
+ If you use the *spec* or *spec_set* arguments then *only* magic methods
that exist in the spec will be created.
.. class:: NonCallableMagicMock(*args, **kw)
- A non-callable version of `MagicMock`.
+ A non-callable version of :class:`MagicMock`.
The constructor parameters have the same meaning as for
- :class:`MagicMock`, with the exception of `return_value` and
- `side_effect` which have no meaning on a non-callable mock.
-
-The magic methods are setup with `MagicMock` objects, so you can configure them
+ :class:`MagicMock`, with the exception of *return_value* and
+ *side_effect* which have no meaning on a non-callable mock.
+
+The magic methods are setup with :class:`MagicMock` objects, so you can configure them
and use them in the usual way:
>>> mock = MagicMock()
@@ -1718,7 +1719,7 @@
>>> object() in mock
False
-The two equality method, `__eq__` and `__ne__`, are special.
+The two equality method, :meth:`__eq__` and :meth:`__ne__`, are special.
They do the default equality comparison on identity, using a side
effect, unless you change their return value to return something else:
@@ -1731,7 +1732,7 @@
>>> mock == 3
True
-The return value of `MagicMock.__iter__` can be any iterable object and isn't
+The return value of :meth:`MagicMock.__iter__` can be any iterable object and isn't
required to be an iterator:
>>> mock = MagicMock()
@@ -1791,10 +1792,10 @@
Sometimes when testing you need to test that a specific object is passed as an
argument to another method, or returned. It can be common to create named
-sentinel objects to test this. `sentinel` provides a convenient way of
+sentinel objects to test this. :data:`sentinel` provides a convenient way of
creating and testing the identity of objects like this.
-In this example we monkey patch `method` to return `sentinel.some_object`:
+In this example we monkey patch ``method`` to return ``sentinel.some_object``:
>>> real = ProductionClass()
>>> real.method = Mock(name="method")
@@ -1811,8 +1812,8 @@
.. data:: DEFAULT
- The `DEFAULT` object is a pre-created sentinel (actually
- `sentinel.DEFAULT`). It can be used by :attr:`~Mock.side_effect`
+ The :data:`DEFAULT` object is a pre-created sentinel (actually
+ ``sentinel.DEFAULT``). It can be used by :attr:`~Mock.side_effect`
functions to indicate that the normal return value should be used.
@@ -1821,9 +1822,9 @@
.. function:: call(*args, **kwargs)
- `call` is a helper object for making simpler assertions, for comparing with
+ :func:`call` is a helper object for making simpler assertions, for comparing with
:attr:`~Mock.call_args`, :attr:`~Mock.call_args_list`,
- :attr:`~Mock.mock_calls` and :attr:`~Mock.method_calls`. `call` can also be
+ :attr:`~Mock.mock_calls` and :attr:`~Mock.method_calls`. :func:`call` can also be
used with :meth:`~Mock.assert_has_calls`.
>>> m = MagicMock(return_value=None)
@@ -1834,11 +1835,11 @@
.. method:: call.call_list()
- For a call object that represents multiple calls, `call_list`
+ For a call object that represents multiple calls, :meth:`call_list`
returns a list of all the intermediate calls as well as the
final call.
-`call_list` is particularly useful for making assertions on "chained calls". A
+``call_list`` is particularly useful for making assertions on "chained calls". A
chained call is multiple calls on a single line of code. This results in
multiple entries in :attr:`~Mock.mock_calls` on a mock. Manually constructing
the sequence of calls can be tedious.
@@ -1860,15 +1861,15 @@
.. _calls-as-tuples:
-A `call` object is either a tuple of (positional args, keyword args) or
+A ``call`` object is either a tuple of (positional args, keyword args) or
(name, positional args, keyword args) depending on how it was constructed. When
-you construct them yourself this isn't particularly interesting, but the `call`
+you construct them yourself this isn't particularly interesting, but the ``call``
objects that are in the :attr:`Mock.call_args`, :attr:`Mock.call_args_list` and
:attr:`Mock.mock_calls` attributes can be introspected to get at the individual
arguments they contain.
-The `call` objects in :attr:`Mock.call_args` and :attr:`Mock.call_args_list`
-are two-tuples of (positional args, keyword args) whereas the `call` objects
+The ``call`` objects in :attr:`Mock.call_args` and :attr:`Mock.call_args_list`
+are two-tuples of (positional args, keyword args) whereas the ``call`` objects
in :attr:`Mock.mock_calls`, along with ones you construct yourself, are
three-tuples of (name, positional args, keyword args).
@@ -1911,25 +1912,25 @@
.. function:: create_autospec(spec, spec_set=False, instance=False, **kwargs)
Create a mock object using another object as a spec. Attributes on the
- mock will use the corresponding attribute on the `spec` object as their
+ mock will use the corresponding attribute on the *spec* object as their
spec.
Functions or methods being mocked will have their arguments checked to
ensure that they are called with the correct signature.
- If `spec_set` is `True` then attempting to set attributes that don't exist
- on the spec object will raise an `AttributeError`.
+ If *spec_set* is ``True`` then attempting to set attributes that don't exist
+ on the spec object will raise an :exc:`AttributeError`.
If a class is used as a spec then the return value of the mock (the
instance of the class) will have the same spec. You can use a class as the
- spec for an instance object by passing `instance=True`. The returned mock
+ spec for an instance object by passing ``instance=True``. The returned mock
will only be callable if instances of the mock are callable.
- `create_autospec` also takes arbitrary keyword arguments that are passed to
+ :func:`create_autospec` also takes arbitrary keyword arguments that are passed to
the constructor of the created mock.
See :ref:`auto-speccing` for examples of how to use auto-speccing with
-`create_autospec` and the `autospec` argument to :func:`patch`.
+:func:`create_autospec` and the *autospec* argument to :func:`patch`.
ANY
@@ -1951,7 +1952,7 @@
>>> mock('foo', bar=object())
>>> mock.assert_called_once_with('foo', bar=ANY)
-`ANY` can also be used in comparisons with call lists like
+:data:`ANY` can also be used in comparisons with call lists like
:attr:`~Mock.mock_calls`:
>>> m = MagicMock(return_value=None)
@@ -1968,15 +1969,15 @@
.. data:: FILTER_DIR
-`FILTER_DIR` is a module level variable that controls the way mock objects
-respond to `dir` (only for Python 2.6 or more recent). The default is `True`,
+:data:`FILTER_DIR` is a module level variable that controls the way mock objects
+respond to :func:`dir` (only for Python 2.6 or more recent). The default is ``True``,
which uses the filtering described below, to only show useful members. If you
dislike this filtering, or need to switch it off for diagnostic purposes, then
-set `mock.FILTER_DIR = False`.
-
-With filtering on, `dir(some_mock)` shows only useful attributes and will
+set ``mock.FILTER_DIR = False``.
+
+With filtering on, ``dir(some_mock)`` shows only useful attributes and will
include any dynamically created attributes that wouldn't normally be shown.
-If the mock was created with a `spec` (or `autospec` of course) then all the
+If the mock was created with a *spec* (or *autospec* of course) then all the
attributes from the original are shown, even if they haven't been accessed
yet:
@@ -1995,11 +1996,11 @@
'BaseHandler',
...
-Many of the not-very-useful (private to `Mock` rather than the thing being
+Many of the not-very-useful (private to :class:`Mock` rather than the thing being
mocked) underscore and double underscore prefixed attributes have been
-filtered from the result of calling `dir` on a `Mock`. If you dislike this
+filtered from the result of calling :func:`dir` on a :class:`Mock`. If you dislike this
behaviour you can switch it off by setting the module level switch
-`FILTER_DIR`:
+:data:`FILTER_DIR`:
>>> from unittest import mock
>>> mock.FILTER_DIR = False
@@ -2013,9 +2014,9 @@
'__class__',
...
-Alternatively you can just use `vars(my_mock)` (instance members) and
-`dir(type(my_mock))` (type members) to bypass the filtering irrespective of
-`mock.FILTER_DIR`.
+Alternatively you can just use ``vars(my_mock)`` (instance members) and
+``dir(type(my_mock))`` (type members) to bypass the filtering irrespective of
+:data:`mock.FILTER_DIR`.
mock_open
@@ -2023,30 +2024,30 @@
.. function:: mock_open(mock=None, read_data=None)
- A helper function to create a mock to replace the use of `open`. It works
- for `open` called directly or used as a context manager.
-
- The `mock` argument is the mock object to configure. If `None` (the
- default) then a `MagicMock` will be created for you, with the API limited
+ A helper function to create a mock to replace the use of :func:`open`. It works
+ for :func:`open` called directly or used as a context manager.
+
+ The *mock* argument is the mock object to configure. If ``None`` (the
+ default) then a :class:`MagicMock` will be created for you, with the API limited
to methods or attributes available on standard file handles.
- `read_data` is a string for the :meth:`~io.IOBase.read`,
+ *read_data* is a string for the :meth:`~io.IOBase.read`,
:meth:`~io.IOBase.readline`, and :meth:`~io.IOBase.readlines` methods
of the file handle to return. Calls to those methods will take data from
- `read_data` until it is depleted. The mock of these methods is pretty
+ *read_data* until it is depleted. The mock of these methods is pretty
simplistic. If you need more control over the data that you are feeding to
the tested code you will need to customize this mock for yourself.
- `read_data` is an empty string by default.
-
-Using `open` as a context manager is a great way to ensure your file handles
+ *read_data* is an empty string by default.
+
+Using :func:`open` as a context manager is a great way to ensure your file handles
are closed properly and is becoming common::
with open('/some/path', 'w') as f:
f.write('something')
-The issue is that even if you mock out the call to `open` it is the
-*returned object* that is used as a context manager (and has `__enter__` and
-`__exit__` called).
+The issue is that even if you mock out the call to :func:`open` it is the
+*returned object* that is used as a context manager (and has :meth:`__enter__` and
+:meth:`__exit__` called).
Mocking context managers with a :class:`MagicMock` is common enough and fiddly
enough that a helper function is useful.
@@ -2080,21 +2081,21 @@
Autospeccing
~~~~~~~~~~~~
-Autospeccing is based on the existing `spec` feature of mock. It limits the
+Autospeccing is based on the existing :attr:`spec` feature of mock. It limits the
api of mocks to the api of an original object (the spec), but it is recursive
(implemented lazily) so that attributes of mocks only have the same api as
the attributes of the spec. In addition mocked functions / methods have the
-same call signature as the original so they raise a `TypeError` if they are
+same call signature as the original so they raise a :exc:`TypeError` if they are
called incorrectly.
Before I explain how auto-speccing works, here's why it is needed.
-`Mock` is a very powerful and flexible object, but it suffers from two flaws
+:class:`Mock` is a very powerful and flexible object, but it suffers from two flaws
when used to mock out objects from a system under test. One of these flaws is
-specific to the `Mock` api and the other is a more general problem with using
+specific to the :class:`Mock` api and the other is a more general problem with using
mock objects.
-First the problem specific to `Mock`. `Mock` has two assert methods that are
+First the problem specific to :class:`Mock`. :class:`Mock` has two assert methods that are
extremely handy: :meth:`~Mock.assert_called_with` and
:meth:`~Mock.assert_called_once_with`.
@@ -2129,8 +2130,8 @@
don't test how your units are "wired together" there is still lots of room
for bugs that tests might have caught.
-`mock` already provides a feature to help with this, called speccing. If you
-use a class or instance as the `spec` for a mock then you can only access
+:mod:`mock` already provides a feature to help with this, called speccing. If you
+use a class or instance as the :attr:`spec` for a mock then you can only access
attributes on the mock that exist on the real class:
>>> from urllib import request
@@ -2149,9 +2150,9 @@
<mock.Mock object at 0x...>
>>> mock.has_data.assret_called_with()
-Auto-speccing solves this problem. You can either pass `autospec=True` to
-`patch` / `patch.object` or use the `create_autospec` function to create a
-mock with a spec. If you use the `autospec=True` argument to `patch` then the
+Auto-speccing solves this problem. You can either pass ``autospec=True`` to
+:func:`patch` / :func:`patch.object` or use the :func:`create_autospec` function to create a
+mock with a spec. If you use the ``autospec=True`` argument to :func:`patch` then the
object that is being replaced will be used as the spec object. Because the
speccing is done "lazily" (the spec is created as attributes on the mock are
accessed) you can use it with very complex or deeply nested objects (like
@@ -2168,8 +2169,8 @@
>>> mock_request.Request
<MagicMock name='request.Request' spec='Request' id='...'>
-You can see that `request.Request` has a spec. `request.Request` takes two
-arguments in the constructor (one of which is `self`). Here's what happens if
+You can see that :class:`request.Request` has a spec. :class:`request.Request` takes two
+arguments in the constructor (one of which is *self*). Here's what happens if
we try to call it incorrectly:
>>> req = request.Request()
@@ -2184,8 +2185,8 @@
>>> req
<NonCallableMagicMock name='request.Request()' spec='Request' id='...'>
-`Request` objects are not callable, so the return value of instantiating our
-mocked out `request.Request` is a non-callable mock. With the spec in place
+:class:`Request` objects are not callable, so the return value of instantiating our
+mocked out :class:`request.Request` is a non-callable mock. With the spec in place
any typos in our asserts will raise the correct error:
>>> req.add_header('spam', 'eggs')
@@ -2196,11 +2197,11 @@
AttributeError: Mock object has no attribute 'assret_called_with'
>>> req.add_header.assert_called_with('spam', 'eggs')
-In many cases you will just be able to add `autospec=True` to your existing
-`patch` calls and then be protected against bugs due to typos and api
+In many cases you will just be able to add ``autospec=True`` to your existing
+:func:`patch` calls and then be protected against bugs due to typos and api
changes.
-As well as using `autospec` through `patch` there is a
+As well as using *autospec* through :func:`patch` there is a
:func:`create_autospec` for creating autospecced mocks directly:
>>> from urllib import request
@@ -2218,8 +2219,8 @@
objects so that introspection is safe [#]_.
A more serious problem is that it is common for instance attributes to be
-created in the `__init__` method and not to exist on the class at all.
-`autospec` can't know about any dynamically created attributes and restricts
+created in the :meth:`__init__` method and not to exist on the class at all.
+*autospec* can't know about any dynamically created attributes and restricts
the api to visible attributes.
>>> class Something:
@@ -2236,7 +2237,7 @@
There are a few different ways of resolving this problem. The easiest, but
not necessarily the least annoying, way is to simply set the required
-attributes on the mock after creation. Just because `autospec` doesn't allow
+attributes on the mock after creation. Just because *autospec* doesn't allow
you to fetch attributes that don't exist on the spec it doesn't prevent you
setting them:
@@ -2245,7 +2246,7 @@
... thing.a = 33
...
-There is a more aggressive version of both `spec` and `autospec` that *does*
+There is a more aggressive version of both *spec* and *autospec* that *does*
prevent you setting non-existent attributes. This is useful if you want to
ensure your code only *sets* valid attributes too, but obviously it prevents
this particular scenario:
@@ -2259,8 +2260,8 @@
AttributeError: Mock object has no attribute 'a'
Probably the best way of solving the problem is to add class attributes as
-default values for instance members initialised in `__init__`. Note that if
-you are only setting default attributes in `__init__` then providing them via
+default values for instance members initialised in :meth:`__init__`. Note that if
+you are only setting default attributes in :meth:`__init__` then providing them via
class attributes (shared between instances of course) is faster too. e.g.
.. code-block:: python
@@ -2269,12 +2270,12 @@
a = 33
This brings up another issue. It is relatively common to provide a default
-value of `None` for members that will later be an object of a different type.
-`None` would be useless as a spec because it wouldn't let you access *any*
-attributes or methods on it. As `None` is *never* going to be useful as a
+value of ``None`` for members that will later be an object of a different type.
+``None`` would be useless as a spec because it wouldn't let you access *any*
+attributes or methods on it. As ``None`` is *never* going to be useful as a
spec, and probably indicates a member that will normally of some other type,
-`autospec` doesn't use a spec for members that are set to `None`. These will
-just be ordinary mocks (well - `MagicMocks`):
+autospec doesn't use a spec for members that are set to ``None``. These will
+just be ordinary mocks (well - MagicMocks):
>>> class Something:
... member = None
@@ -2288,8 +2289,8 @@
spec rather than the class. The other is to create a subclass of the
production class and add the defaults to the subclass without affecting the
production class. Both of these require you to use an alternative object as
-the spec. Thankfully `patch` supports this - you can simply pass the
-alternative object as the `autospec` argument:
+the spec. Thankfully :func:`patch` supports this - you can simply pass the
+alternative object as the *autospec* argument:
>>> class Something:
... def __init__(self):
@@ -2306,5 +2307,5 @@
.. [#] This only applies to classes or already instantiated objects. Calling
a mocked class to create a mock instance *does not* create a real instance.
- It is only attribute lookups - along with calls to `dir` - that are done.
-
+ It is only attribute lookups - along with calls to :func:`dir` - that are done.
+
--
Repository URL: https://hg.python.org/cpython
More information about the Python-checkins
mailing list