Mailman 3 October 2014 - Python-checkins

cpython (3.4): #22613: elaborate on arguments of shutil archival functions (thanks Jacques
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/7d40eff70601 changeset: 93308:7d40eff70601 branch: 3.4 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 10:02:40 2014 +0100 summary: #22613: elaborate on arguments of shutil archival functions (thanks Jacques Ducasse) files: Doc/library/shutil.rst | 16 +++++++++++++--- 1 files changed, 13 insertions(+), 3 deletions(-) diff --git a/Doc/library/shutil.rst b/Doc/library/shutil.rst --- a/Doc/library/shutil.rst +++ b/Doc/library/shutil.rst @@ -449,12 +449,17 @@ *root_dir* and *base_dir* both default to the current directory. + If *dry_run* is true, no archive is created, but the operations that would be + executed are logged to *logger*. + *owner* and *group* are used when creating a tar archive. By default, uses the current owner and group. *logger* must be an object compatible with :pep:`282`, usually an instance of :class:`logging.Logger`. + The *verbose* argument is currently unused. + .. function:: get_archive_formats() @@ -474,14 +479,19 @@ .. function:: register_archive_format(name, function, [extra_args, [description]]) - Register an archiver for the format *name*. *function* is a callable that - will be used to invoke the archiver. + Register an archiver for the format *name*. + + *function* is the callable that will be used to unpack archives. The callable + will receive the *base_name* of the file to create, followed by the + *base_dir* (which defaults to :data:`os.curdir`) to start archiving from. + Further arguments are passed as keyword arguments: *owner*, *group*, + *dry_run* and *logger* (as passed in :func:`make_archive`). If given, *extra_args* is a sequence of ``(name, value)`` pairs that will be used as extra keywords arguments when the archiver callable is used. *description* is used by :func:`get_archive_formats` which returns the - list of archivers. Defaults to an empty list. + list of archivers. Defaults to an empty string. .. function:: unregister_archive_format(name) -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.4): #22613: fix heading levels in tracemalloc docs (thanks Jacques Ducasse)
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/307fd58b9694 changeset: 93309:307fd58b9694 branch: 3.4 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 10:21:07 2014 +0100 summary: #22613: fix heading levels in tracemalloc docs (thanks Jacques Ducasse) files: Doc/library/tracemalloc.rst | 28 ++++++++++++------------ 1 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Doc/library/tracemalloc.rst b/Doc/library/tracemalloc.rst --- a/Doc/library/tracemalloc.rst +++ b/Doc/library/tracemalloc.rst @@ -27,10 +27,10 @@ Examples -======== +-------- Display the top 10 ------------------- +^^^^^^^^^^^^^^^^^^ Display the 10 files allocating the most memory:: @@ -70,7 +70,7 @@ Compute differences -------------------- +^^^^^^^^^^^^^^^^^^^ Take two snapshots and display the differences:: @@ -114,7 +114,7 @@ Get the traceback of a memory block ------------------------------------ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Code to display the traceback of the biggest memory block:: @@ -179,7 +179,7 @@ Pretty top ----------- +^^^^^^^^^^ Code to display the 10 lines allocating the most memory with a pretty output, ignoring ``<frozen importlib._bootstrap>`` and ``<unknown>`` files:: @@ -249,10 +249,10 @@ API -=== +--- Functions ---------- +^^^^^^^^^ .. function:: clear_traces() @@ -356,7 +356,7 @@ Filter ------- +^^^^^^ .. class:: Filter(inclusive: bool, filename_pattern: str, lineno: int=None, all_frames: bool=False) @@ -404,7 +404,7 @@ Frame ------ +^^^^^ .. class:: Frame @@ -422,7 +422,7 @@ Snapshot --------- +^^^^^^^^ .. class:: Snapshot @@ -508,7 +508,7 @@ Statistic ---------- +^^^^^^^^^ .. class:: Statistic @@ -533,7 +533,7 @@ StatisticDiff -------------- +^^^^^^^^^^^^^ .. class:: StatisticDiff @@ -572,7 +572,7 @@ Trace ------ +^^^^^ .. class:: Trace @@ -592,7 +592,7 @@ Traceback ---------- +^^^^^^^^^ .. class:: Traceback -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.4): #22613: document Cmd.cmdqueue (thanks Jacques Ducasse)
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/0a217d3d581c changeset: 93310:0a217d3d581c branch: 3.4 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 10:25:38 2014 +0100 summary: #22613: document Cmd.cmdqueue (thanks Jacques Ducasse) files: Doc/library/cmd.rst | 9 ++++++++- 1 files changed, 8 insertions(+), 1 deletions(-) diff --git a/Doc/library/cmd.rst b/Doc/library/cmd.rst --- a/Doc/library/cmd.rst +++ b/Doc/library/cmd.rst @@ -148,9 +148,9 @@ Hook method executed once when :meth:`cmdloop` is about to return. This method is a stub in :class:`Cmd`; it exists to be overridden by subclasses. + Instances of :class:`Cmd` subclasses have some public instance variables: - .. attribute:: Cmd.prompt The prompt issued to solicit input. @@ -166,6 +166,13 @@ The last nonempty command prefix seen. +.. attribute:: Cmd.cmdqueue + + A list of queued input lines. The cmdqueue list is checked in + :meth:`cmdloop` when new input is needed; if it is nonempty, its elements + will be processed in order, as if entered at the prompt. + + .. attribute:: Cmd.intro A string to issue as an intro or banner. May be overridden by giving the -- Repository URL: https://hg.python.org/cpython

1 0

Daily reference leaks (1d87ac92b041): sum=3
by solipsis＠pitrou.net 31 Oct '14

31 Oct '14

results for 1d87ac92b041 on branch "default" -------------------------------------------- test_functools leaked [0, 0, 3] memory blocks, sum=3 Command line was: ['./python', '-m', 'test.regrtest', '-uall', '-R', '3:3:/home/antoine/cpython/refleaks/reflogMBWr5U', '-x']

1 0

cpython (2.7): minor grammar fixes (from docs@python.org)
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/0f6dd5365370 changeset: 93305:0f6dd5365370 branch: 2.7 parent: 93296:d565dbf576f9 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 09:29:38 2014 +0100 summary: minor grammar fixes (from docs(a)python.org) files: Doc/tutorial/classes.rst | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Doc/tutorial/classes.rst b/Doc/tutorial/classes.rst --- a/Doc/tutorial/classes.rst +++ b/Doc/tutorial/classes.rst @@ -826,7 +826,7 @@ :term:`Generator`\s are a simple and powerful tool for creating iterators. They are written like regular functions but use the :keyword:`yield` statement whenever they want to return data. Each time :func:`next` is called on it, the -generator resumes where it left-off (it remembers all the data values and which +generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:: @@ -844,7 +844,7 @@ o g -Anything that can be done with generators can also be done with class based +Anything that can be done with generators can also be done with class-based iterators as described in the previous section. What makes generators so compact is that the :meth:`__iter__` and :meth:`~generator.next` methods are created automatically. -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.4 -> default): merge with 3.4
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/0e8411d268a0 changeset: 93304:0e8411d268a0 parent: 93302:2b7277903930 parent: 93303:253b97bf87d4 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 09:29:48 2014 +0100 summary: merge with 3.4 files: Doc/tutorial/classes.rst | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Doc/tutorial/classes.rst b/Doc/tutorial/classes.rst --- a/Doc/tutorial/classes.rst +++ b/Doc/tutorial/classes.rst @@ -869,7 +869,7 @@ :term:`Generator`\s are a simple and powerful tool for creating iterators. They are written like regular functions but use the :keyword:`yield` statement whenever they want to return data. Each time :func:`next` is called on it, the -generator resumes where it left-off (it remembers all the data values and which +generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:: @@ -887,7 +887,7 @@ o g -Anything that can be done with generators can also be done with class based +Anything that can be done with generators can also be done with class-based iterators as described in the previous section. What makes generators so compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods are created automatically. -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.4): minor grammar fixes (from docs@python.org)
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/253b97bf87d4 changeset: 93303:253b97bf87d4 branch: 3.4 parent: 93300:2ff8b5ef1b16 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 09:29:38 2014 +0100 summary: minor grammar fixes (from docs(a)python.org) files: Doc/tutorial/classes.rst | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Doc/tutorial/classes.rst b/Doc/tutorial/classes.rst --- a/Doc/tutorial/classes.rst +++ b/Doc/tutorial/classes.rst @@ -869,7 +869,7 @@ :term:`Generator`\s are a simple and powerful tool for creating iterators. They are written like regular functions but use the :keyword:`yield` statement whenever they want to return data. Each time :func:`next` is called on it, the -generator resumes where it left-off (it remembers all the data values and which +generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:: @@ -887,7 +887,7 @@ o g -Anything that can be done with generators can also be done with class based +Anything that can be done with generators can also be done with class-based iterators as described in the previous section. What makes generators so compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods are created automatically. -- Repository URL: https://hg.python.org/cpython

1 0

cpython: Doc: updadate suspicious ignore rules
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/2b7277903930 changeset: 93302:2b7277903930 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 08:03:20 2014 +0100 summary: Doc: updadate suspicious ignore rules files: Doc/tools/susp-ignored.csv | 12 +++++++----- 1 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Doc/tools/susp-ignored.csv b/Doc/tools/susp-ignored.csv --- a/Doc/tools/susp-ignored.csv +++ b/Doc/tools/susp-ignored.csv @@ -122,6 +122,8 @@ library/ipaddress,,::,>>> ipaddress.IPv6Address('2001:db8::1000') library/ipaddress,,:db8,IPv6Address('2001:db8::1000') library/ipaddress,,::,IPv6Address('2001:db8::1000') +library/ipaddress,,:db8,">>> ipaddress.ip_address(""2001:db8::1"").reverse_pointer" +library/ipaddress,,::,">>> ipaddress.ip_address(""2001:db8::1"").reverse_pointer" library/ipaddress,,::,"""::abc:7:def""" library/ipaddress,,:def,"""::abc:7:def""" library/ipaddress,,::,::FFFF/96 @@ -256,11 +258,11 @@ whatsnew/2.5,,:memory,:memory: whatsnew/2.5,,:step,[start:stop:step] whatsnew/2.5,,:stop,[start:stop:step] -whatsnew/2.7,1619,::,"ParseResult(scheme='http', netloc='[1080::8:800:200C:417A]'," -whatsnew/2.7,1619,::,>>> urlparse.urlparse('http://[1080::8:800:200C:417A]/foo') -whatsnew/2.7,735,:Sunday,'2009:4:Sunday' -whatsnew/2.7,862,:Cookie,"export PYTHONWARNINGS=all,error:::Cookie:0" -whatsnew/2.7,862,::,"export PYTHONWARNINGS=all,error:::Cookie:0" +whatsnew/2.7,,::,"ParseResult(scheme='http', netloc='[1080::8:800:200C:417A]'," +whatsnew/2.7,,::,>>> urlparse.urlparse('http://[1080::8:800:200C:417A]/foo') +whatsnew/2.7,,:Sunday,'2009:4:Sunday' +whatsnew/2.7,,:Cookie,"export PYTHONWARNINGS=all,error:::Cookie:0" +whatsnew/2.7,,::,"export PYTHONWARNINGS=all,error:::Cookie:0" whatsnew/3.2,,:affe,"netloc='[dead:beef:cafe:5417:affe:8FA3:deaf:feed]'," whatsnew/3.2,,:affe,>>> urllib.parse.urlparse('http://[dead:beef:cafe:5417:affe:8FA3:deaf:feed]/foo/') whatsnew/3.2,,:beef,"netloc='[dead:beef:cafe:5417:affe:8FA3:deaf:feed]'," -- Repository URL: https://hg.python.org/cpython

1 0

cpython (merge 3.4 -> default): merge with 3.4
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/980df829af33 changeset: 93301:980df829af33 parent: 93299:5a687f9ee76d parent: 93300:2ff8b5ef1b16 user: Georg Brandl <georg(a)python.org> date: Fri Oct 31 07:59:59 2014 +0100 summary: merge with 3.4 files: -- Repository URL: https://hg.python.org/cpython

1 0

cpython (3.4): unittest.mock docs: fix use of default role
by georg.brandl 31 Oct '14

31 Oct '14

https://hg.python.org/cpython/rev/2ff8b5ef1b16 changeset: 93300:2ff8b5ef1b16 branch: 3.4 parent: 93297:0c016fa378db user: Georg Brandl <georg(a)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 | 494 ++++++------ 2 files changed, 372 insertions(+), 372 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. @@ -296,13 +296,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) @@ -329,7 +329,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. @@ -337,11 +337,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) @@ -382,14 +382,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 @@ -449,7 +449,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 @@ -479,17 +479,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) @@ -500,7 +500,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 @@ -510,7 +510,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() @@ -524,7 +524,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 @@ -547,7 +547,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 @@ -560,7 +560,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() @@ -572,7 +572,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>`. @@ -590,15 +590,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) @@ -615,24 +615,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 @@ -641,12 +641,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) @@ -655,11 +655,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: @@ -671,7 +671,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) @@ -709,10 +709,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: @@ -734,7 +734,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() @@ -758,7 +758,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 @@ -779,8 +779,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: @@ -797,7 +797,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): @@ -814,8 +814,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): @@ -828,9 +828,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() @@ -867,12 +867,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') @@ -958,7 +958,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>`. @@ -978,53 +978,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 @@ -1059,16 +1059,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): @@ -1081,7 +1081,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 @@ -1091,7 +1091,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: @@ -1104,7 +1104,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(): @@ -1117,7 +1117,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: @@ -1133,7 +1133,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) @@ -1151,19 +1151,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. @@ -1178,8 +1178,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 @@ -1190,27 +1190,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. @@ -1227,7 +1227,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' @@ -1237,11 +1237,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): @@ -1277,21 +1277,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() @@ -1304,8 +1304,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) @@ -1316,7 +1316,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: @@ -1332,16 +1332,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 @@ -1354,8 +1354,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): @@ -1377,7 +1377,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: @@ -1407,11 +1407,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 @@ -1464,7 +1464,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. @@ -1482,23 +1482,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') @@ -1554,7 +1554,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') @@ -1570,8 +1570,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: @@ -1607,7 +1607,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) @@ -1618,19 +1618,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() @@ -1677,7 +1677,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: @@ -1690,7 +1690,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() @@ -1750,10 +1750,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") @@ -1770,8 +1770,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. @@ -1780,9 +1780,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) @@ -1793,11 +1793,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. @@ -1819,15 +1819,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). @@ -1870,25 +1870,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 @@ -1910,7 +1910,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) @@ -1927,15 +1927,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: @@ -1954,11 +1954,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 @@ -1972,9 +1972,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 @@ -1982,30 +1982,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. @@ -2039,21 +2039,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`. @@ -2088,8 +2088,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 @@ -2108,9 +2108,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 @@ -2127,8 +2127,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() @@ -2143,8 +2143,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') @@ -2155,11 +2155,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 @@ -2177,8 +2177,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: @@ -2195,7 +2195,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: @@ -2204,7 +2204,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: @@ -2218,8 +2218,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 @@ -2228,12 +2228,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 @@ -2247,8 +2247,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): @@ -2265,5 +2265,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

1 0