unittest.mock —- 模拟对象库

3.3 新版功能.

源代码：Lib/unittest/mock.py

unittest.mock 是一个用于测试的Python库。它允许使用模拟对象来替换受测系统的部分，并对它们如何已经被使用进行断言。

unittest.mock provides a core Mock class removing the need tocreate a host of stubs throughout your test suite. After performing anaction, you can make assertions about which methods / attributes were usedand arguments they were called with. You can also specify return values andset needed attributes in the normal way.

Additionally, mock provides a patch() decorator that handles patchingmodule and class level attributes within the scope of a test, along withsentinel for creating unique objects. See the quick guide forsome examples of how to use Mock, MagicMock andpatch().

Mock is very easy to use and is designed for use with unittest. Mockis 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,available as mock on PyPI.

Quick Guide

Mock and MagicMock objects create all attributes andmethods as you access them and store details of how they have been used. Youcan configure them, to specify return values or limit what attributes areavailable, and then make assertions about how they have been used:

>>> from unittest.mock import MagicMock
>>> thing = ProductionClass()
>>> thing.method = MagicMock(return_value=3)
>>> thing.method(3, 4, 5, key='value')
3
>>> thing.method.assert_called_with(3, 4, 5, key='value')

side_effect allows you to perform side effects, including raising anexception when a mock is called:

>>> mock = Mock(side_effect=KeyError('foo'))
>>> mock()
Traceback (most recent call last):
 ...
KeyError: 'foo'

>>> values = {'a': 1, 'b': 2, 'c': 3}
>>> def side_effect(arg):
...     return values[arg]
...
>>> mock.side_effect = side_effect
>>> mock('a'), mock('b'), mock('c')
(1, 2, 3)
>>> mock.side_effect = [5, 4, 3, 2, 1]
>>> mock(), mock(), mock()
(5, 4, 3)

Mock has many other ways you can configure it and control its behaviour. Forexample the spec argument configures the mock to take its specificationfrom another object. Attempting to access attributes or methods on the mockthat don't exist on the spec will fail with an AttributeError.

The patch() decorator / context manager makes it easy to mock classes orobjects in a module under test. The object you specify will be replaced with amock (or other object) during the test and restored when the test ends:

>>> from unittest.mock import patch
>>> @patch('module.ClassName2')
... @patch('module.ClassName1')
... def test(MockClass1, MockClass2):
...     module.ClassName1()
...     module.ClassName2()
...     assert MockClass1 is module.ClassName1
...     assert MockClass2 is module.ClassName2
...     assert MockClass1.called
...     assert MockClass2.called
...
>>> test()

注解

When you nest patch decorators the mocks are passed in to the decoratedfunction in the same order they applied (the normal Python order thatdecorators are applied). This means from the bottom up, so in the exampleabove the mock for module.ClassName1 is passed in first.

With patch() it matters that you patch objects in the namespace where theyare looked up. This is normally straightforward, but for a quick guideread where to patch.

As well as a decorator patch() can be used as a context manager in a withstatement:

>>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:
...     thing = ProductionClass()
...     thing.method(1, 2, 3)
...
>>> mock_method.assert_called_once_with(1, 2, 3)

There is also patch.dict() for setting values in a dictionary justduring a scope and restoring the dictionary to its original state when the testends:

>>> foo = {'key': 'value'}
>>> original = foo.copy()
>>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):
...     assert foo == {'newkey': 'newvalue'}
...
>>> assert foo == original

Mock supports the mocking of Python magic methods. Theeasiest way of using magic methods is with the MagicMock class. Itallows you to do things like:

>>> mock = MagicMock()
>>> mock.__str__.return_value = 'foobarbaz'
>>> str(mock)
'foobarbaz'
>>> mock.__str__.assert_called_with()

Mock allows you to assign functions (or other Mock instances) to magic methodsand they will be called appropriately. The MagicMock class is just a Mockvariant that has all of the magic methods pre-created for you (well, all theuseful ones anyway).

The following is an example of using magic methods with the ordinary Mockclass:

>>> mock = Mock()
>>> mock.__str__ = Mock(return_value='wheeeeee')
>>> str(mock)
'wheeeeee'

For ensuring that the mock objects in your tests have the same api as theobjects they are replacing, you can use auto-speccing.Auto-speccing can be done through the autospec argument to patch, or thecreate_autospec() function. Auto-speccing creates mock objects thathave the same attributes and methods as the objects they are replacing, andany functions and methods (including constructors) have the same callsignature as the real object.

This ensures that your mocks will fail in the same way as your productioncode if they are used incorrectly:

>>> from unittest.mock import create_autospec
>>> def function(a, b, c):
...     pass
...
>>> mock_function = create_autospec(function, return_value='fishy')
>>> mock_function(1, 2, 3)
'fishy'
>>> mock_function.assert_called_once_with(1, 2, 3)
>>> mock_function('wrong arguments')
Traceback (most recent call last):
 ...
TypeError: <lambda>() takes exactly 3 arguments (1 given)

create_autospec() can also be used on classes, where it copies the signature ofthe init method, and on callable objects where it copies the signature ofthe call method.

The Mock Class

Mock is a flexible mock object intended to replace the use of stubs andtest doubles throughout your code. Mocks are callable and create attributes asnew mocks when you access them 1. Accessing the same attribute will alwaysreturn the same mock. Mocks record how you use them, allowing you to makeassertions about what your code has done to them.

MagicMock is a subclass of Mock with all the magic methodspre-created and ready to use. There are also non-callable variants, usefulwhen you are mocking out objects that aren't callable:NonCallableMock and NonCallableMagicMock

The patch() decorators makes it easy to temporarily replace classesin a particular module with a Mock object. By default patch() will createa MagicMock for you. You can specify an alternative class of Mock usingthe new_callable argument to patch().

• class unittest.mock.Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)

• Create a new Mock object. Mock takes several optional argumentsthat specify the behaviour of the Mock object:

  • spec: This can be either a list of strings or an existing object (aclass or instance) that acts as the specification for the mock object. Ifyou pass in an object then a list of strings is formed by calling dir onthe object (excluding unsupported magic attributes and methods).Accessing any attribute not in this list will raise an AttributeError.

If spec is an object (rather than a list of strings) thenclass returns the class of the spec object. Thisallows mocks to pass isinstance() tests.

• spec_set: A stricter variant of spec. If used, attempting to set_or get an attribute on the mock that isn't on the object passed as_spec_set will raise an AttributeError.

• side_effect: A function to be called whenever the Mock is called. Seethe side_effect attribute. Useful for raising exceptions ordynamically changing return values. The function is called with the samearguments as the mock, and unless it returns DEFAULT, the returnvalue of this function is used as the return value.

Alternatively side_effect can be an exception class or instance. Inthis case the exception will be raised when the mock is called.

If side_effect is an iterable then each call to the mock will returnthe next value from the iterable.

A side_effect can be cleared by setting it to None.

• return_value: The value returned when the mock is called. By defaultthis is a new Mock (created on first access). See thereturn_value attribute.

• unsafe: By default if any attribute starts with assert orassret will raise an AttributeError. Passing unsafe=Truewill allow access to these attributes.

3.5 新版功能.

• wraps: Item for the mock object to wrap. If wraps is not None thencalling the Mock will pass the call through to the wrapped object(returning the real result). Attribute access on the mock will return aMock object that wraps the corresponding attribute of the wrappedobject (so attempting to access an attribute that doesn't exist willraise an AttributeError).

If the mock has an explicit return_value set then calls are not passedto the wrapped object and the return_value is returned instead.

• name: If the mock has a name then it will be used in the repr of themock. This can be useful for debugging. The name is propagated to childmocks.

Mocks can also be called with arbitrary keyword arguments. These will beused to set attributes on the mock after it is created. See theconfigure_mock() method for details.

• assert_called()
• Assert that the mock was called at least once.

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called()

3.6 新版功能.

• assert_called_once()
• Assert that the mock was called exactly once.

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_once()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_once()
Traceback (most recent call last):
...
AssertionError: Expected 'method' to have been called once. Called 2 times.

3.6 新版功能.

• assertcalled_with(args, *kwargs_)
• This method is a convenient way of asserting that calls are made in aparticular way:

>>> mock = Mock()
>>> mock.method(1, 2, 3, test='wow')
<Mock name='mock.method()' id='...'>
>>> mock.method.assert_called_with(1, 2, 3, test='wow')

• assertcalled_once_with(args, *kwargs_)
• Assert that the mock was called exactly once and that that call waswith the specified arguments.

>>> mock = Mock(return_value=None)
>>> mock('foo', bar='baz')
>>> mock.assert_called_once_with('foo', bar='baz')
>>> mock('other', bar='values')
>>> mock.assert_called_once_with('other', bar='values')
Traceback (most recent call last):
  ...
AssertionError: Expected 'mock' to be called once. Called 2 times.

• assertany_call(args, *kwargs_)
• assert the mock has been called with the specified arguments.

The assert passes if the mock has ever been called, unlikeassert_called_with() and assert_called_once_with() thatonly pass if the call is the most recent one, and in the case ofassert_called_once_with() it must also be the only call.

>>> mock = Mock(return_value=None)
>>> mock(1, 2, arg='thing')
>>> mock('some', 'thing', 'else')
>>> mock.assert_any_call(1, 2, arg='thing')

• asserthas_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 then the calls must besequential. There can be extra calls before or after thespecified calls.

If any_order is true then the calls can be in any order, butthey must all appear in mock_calls.

>>> mock = Mock(return_value=None)
>>> mock(1)
>>> mock(2)
>>> mock(3)
>>> mock(4)
>>> calls = [call(2), call(3)]
>>> mock.assert_has_calls(calls)
>>> calls = [call(4), call(2), call(3)]
>>> mock.assert_has_calls(calls, any_order=True)

• assert_not_called()
• Assert the mock was never called.

>>> m = Mock()
>>> m.hello.assert_not_called()
>>> obj = m.hello()
>>> m.hello.assert_not_called()
Traceback (most recent call last):
  ...
AssertionError: Expected 'hello' to not have been called. Called 1 times.

3.5 新版功能.

• resetmock(*, _return_value=False, side_effect=False)
• The reset_mock method resets all the call attributes on a mock object:

>>> mock = Mock(return_value=None)
>>> mock('hello')
>>> mock.called
True
>>> mock.reset_mock()
>>> mock.called
False

在 3.6 版更改: Added two keyword only argument to the reset_mock function.

This can be useful where you want to make a series of assertions thatreuse the same object. Note that reset_mock()doesn't clear thereturn value, side_effect or any child attributes you haveset using normal assignment by default. In case you want to resetreturn_value or side_effect, then pass the correspondingparameter as True. Child mocks and the return value mock(if any) are reset as well.

注解

return_value, and side_effect are keyword onlyargument.

• mockadd_spec(_spec, spec_set=False)
• Add a spec to a mock. spec can either be an object or alist of strings. Only attributes on the spec can be fetched asattributes from the mock.

If spec_set is true then only attributes on the spec can be set.

• attachmock(_mock, attribute)

• Attach a mock as an attribute of this one, replacing its name andparent. Calls to the attached mock will be recorded in themethod_calls and mock_calls attributes of this one.

• configuremock(**kwargs_)

• Set attributes on the mock through keyword arguments.

Attributes plus return values and side effects can be set on childmocks using standard dot notation and unpacking a dictionary in themethod call:

>>> mock = Mock()
>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock.configure_mock(**attrs)
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

The same thing can be achieved in the constructor call to mocks:

>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock = Mock(some_attribute='eggs', **attrs)
>>> mock.some_attribute
'eggs'
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

configure_mock() exists to make it easier to do configurationafter the mock has been created.

• dir()
• Mock objects limit the results of dir(somemock) to useful results.For mocks with a _spec this includes all the permitted attributesfor the mock.

See FILTER_DIR for what this filtering does, and how toswitch it off.

• get_child_mock(**kw_)
• Create the child mocks for attributes and return value.By default child mocks will be the same type as the parent.Subclasses of Mock may want to override this to customize the waychild mocks are made.

For non-callable mocks the callable variant will be used (rather thanany custom subclass).

• called
• A boolean representing whether or not the mock object has been called:

>>> mock = Mock(return_value=None)
>>> mock.called
False
>>> mock()
>>> mock.called
True

• call_count
• An integer telling you how many times the mock object has been called:

>>> mock = Mock(return_value=None)
>>> mock.call_count
0
>>> mock()
>>> mock()
>>> mock.call_count
2

• return_value
• Set this to configure the value returned by calling the mock:

>>> mock = Mock()
>>> mock.return_value = 'fish'
>>> mock()
'fish'

The default return value is a mock object and you can configure it inthe normal way:

>>> mock = Mock()
>>> mock.return_value.attribute = sentinel.Attribute
>>> mock.return_value()
<Mock name='mock()()' id='...'>
>>> mock.return_value.assert_called_with()

return_value can also be set in the constructor:

>>> mock = Mock(return_value=3)
>>> mock.return_value
3
>>> mock()
3

• side_effect
• This can either be a function to be called when the mock is called,an iterable or an exception (class or instance) to be raised.

If you pass in a function it will be called with same arguments as themock and unless the function returns the DEFAULT singleton thecall to the mock will then return whatever the function returns. If thefunction returns DEFAULT then the mock will return its normalvalue (from the return_value).

If you pass in an iterable, it is used to retrieve an iterator whichmust yield a value on every call. This value can either be an exceptioninstance to be raised, or a value to be returned from the call to themock (DEFAULT handling is identical to the function case).

An example of a mock that raises an exception (to test exceptionhandling of an API):

>>> mock = Mock()
>>> mock.side_effect = Exception('Boom!')
>>> mock()
Traceback (most recent call last):
  ...
Exception: Boom!

Using side_effect to return a sequence of values:

>>> mock = Mock()
>>> mock.side_effect = [3, 2, 1]
>>> mock(), mock(), mock()
(3, 2, 1)

Using a callable:

>>> mock = Mock(return_value=3)
>>> def side_effect(*args, **kwargs):
...     return DEFAULT
...
>>> mock.side_effect = side_effect
>>> mock()
3

side_effect can be set in the constructor. Here's an example thatadds one to the value the mock is called with and returns it:

>>> side_effect = lambda value: value + 1
>>> mock = Mock(side_effect=side_effect)
>>> mock(3)
4
>>> mock(-8)
-7

Setting side_effect to None clears it:

>>> m = Mock(side_effect=KeyError, return_value=3)
>>> m()
Traceback (most recent call last):
 ...
KeyError
>>> m.side_effect = None
>>> m()
3

• call_args
• This is either None (if the mock hasn't been called), or thearguments that the mock was last called with. This will be in theform of a tuple: the first member is any ordered arguments the mockwas called with (or an empty tuple) and the second member is anykeyword arguments (or an empty dictionary).

>>> mock = Mock(return_value=None)
>>> print(mock.call_args)
None
>>> mock()
>>> mock.call_args
call()
>>> mock.call_args == ()
True
>>> mock(3, 4)
>>> mock.call_args
call(3, 4)
>>> mock.call_args == ((3, 4),)
True
>>> mock(3, 4, 5, key='fish', next='w00t!')
>>> mock.call_args
call(3, 4, 5, key='fish', next='w00t!')

call_args, along with members of the lists call_args_list,method_calls and mock_calls are call objects.These are tuples, so they can be unpacked to get at the individualarguments and make more complex assertions. Seecalls as tuples.

• call_args_list
• This is a list of all the calls made to the mock object in sequence(so the length of the list is the number of times it has beencalled). Before any calls have been made it is an empty list. Thecall object can be used for conveniently constructing lists ofcalls to compare with call_args_list.

>>> mock = Mock(return_value=None)
>>> mock()
>>> mock(3, 4)
>>> mock(key='fish', next='w00t!')
>>> mock.call_args_list
[call(), call(3, 4), call(key='fish', next='w00t!')]
>>> expected = [(), ((3, 4),), ({'key': 'fish', 'next': 'w00t!'},)]
>>> mock.call_args_list == expected
True

Members of call_args_list are call objects. These can beunpacked as tuples to get at the individual arguments. Seecalls as tuples.

• method_calls
• As well as tracking calls to themselves, mocks also track calls tomethods and attributes, and their methods and attributes:

>>> mock = Mock()
>>> mock.method()
<Mock name='mock.method()' id='...'>
>>> mock.property.method.attribute()
<Mock name='mock.property.method.attribute()' id='...'>
>>> mock.method_calls
[call.method(), call.property.method.attribute()]

Members of method_calls are call objects. These can beunpacked as tuples to get at the individual arguments. Seecalls as tuples.

• mock_calls
• mock_calls records all calls to the mock object, its methods,magic methods and return value mocks.

>>> mock = MagicMock()
>>> result = mock(1, 2, 3)
>>> mock.first(a=3)
<MagicMock name='mock.first()' id='...'>
>>> mock.second()
<MagicMock name='mock.second()' id='...'>
>>> int(mock)
1
>>> result(1)
<MagicMock name='mock()()' id='...'>
>>> expected = [call(1, 2, 3), call.first(a=3), call.second(),
... call.__int__(), call()(1)]
>>> mock.mock_calls == expected
True

Members of mock_calls are call objects. These can beunpacked as tuples to get at the individual arguments. Seecalls as tuples.

注解

The way mock_calls are recorded means that where nestedcalls are made, the parameters of ancestor calls are not recordedand so will always compare equal:

>>> mock = MagicMock()
>>> mock.top(a=3).bottom()
<MagicMock name='mock.top().bottom()' id='...'>
>>> mock.mock_calls
[call.top(a=3), call.top().bottom()]
>>> mock.mock_calls[-1] == call.top(a=-1).bottom()
True

• class
• Normally the class attribute of an object will return its type.For a mock object with a spec, class returns the spec classinstead. This allows mock objects to pass isinstance() tests for theobject they are replacing / masquerading as:

>>> mock = Mock(spec=3)
>>> isinstance(mock, int)
True

class is assignable to, this allows a mock to pass anisinstance() check without forcing you to use a spec:

>>> mock = Mock()
>>> mock.__class__ = dict
>>> isinstance(mock, dict)
True

• class unittest.mock.NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)
• A non-callable version of Mock. The constructor parameters have the samemeaning of 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 orspec_set are able to pass isinstance() tests:

>>> mock = Mock(spec=SomeClass)
>>> isinstance(mock, SomeClass)
True
>>> mock = Mock(spec_set=SomeClass())
>>> isinstance(mock, SomeClass)
True

The Mock classes have support for mocking magic methods. See magicmethods for the full details.

The mock classes and the patch() decorators all take arbitrary keywordarguments for configuration. For the patch() decorators the keywords arepassed to the constructor of the mock being created. The keyword argumentsare for configuring attributes of the mock:

>>> m = MagicMock(attribute=3, other='fish')
>>> m.attribute
3
>>> m.other
'fish'

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 youhave to create a dictionary and unpack it using **:

>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> mock = Mock(some_attribute='eggs', **attrs)
>>> mock.some_attribute
'eggs'
>>> mock.method()
3
>>> mock.other()
Traceback (most recent call last):
  ...
KeyError

A callable mock which was created with a spec (or a spec_set) willintrospect the specification object's signature when matching calls tothe mock. Therefore, it can match the actual call's arguments regardlessof whether they were passed positionally or by name:

>>> def f(a, b, c): pass
...
>>> mock = Mock(spec=f)
>>> mock(1, 2, c=3)
<Mock name='mock()' id='140161580456576'>
>>> mock.assert_called_with(1, 2, 3)
>>> mock.assert_called_with(a=1, b=2, c=3)

This applies to assert_called_with(),assert_called_once_with(), assert_has_calls() andassert_any_call(). When Autospeccing, it will alsoapply to method calls on the mock object.

在 3.4 版更改: Added signature introspection on specced and autospecced mock objects.

• class unittest.mock.PropertyMock(*args, **kwargs)
• A mock intended to be used as a property, or other descriptor, on a class.PropertyMock provides get() and set() methodsso you can specify a return value when it is fetched.

Fetching a PropertyMock instance from an object calls the mock, withno args. Setting it calls the mock with the value being set.

>>> class Foo:
...     @property
...     def foo(self):
...         return 'something'
...     @foo.setter
...     def foo(self, value):
...         pass
...
>>> with patch('__main__.Foo.foo', new_callable=PropertyMock) as mock_foo:
...     mock_foo.return_value = 'mockity-mock'
...     this_foo = Foo()
...     print(this_foo.foo)
...     this_foo.foo = 6
...
mockity-mock
>>> mock_foo.mock_calls
[call(), call(6)]

Because of the way mock attributes are stored you can't directly attach aPropertyMock to a mock object. Instead you can attach it to the mock typeobject:

>>> m = MagicMock()
>>> p = PropertyMock(return_value=3)
>>> type(m).foo = p
>>> m.foo
3
>>> p.assert_called_once_with()

Calling

Mock objects are callable. The call will return the value set as thereturn_value attribute. The default return value is a new Mockobject; it is created the first time the return value is accessed (eitherexplicitly or by calling the Mock) - but it is stored and the same onereturned each time.

Calls made to the object will be recorded in the attributeslike call_args and call_args_list.

If side_effect is set then it will be called after the call hasbeen recorded, so if side_effect raises an exception the call is stillrecorded.

The simplest way to make a mock raise an exception when called is to makeside_effect an exception class or instance:

>>> m = MagicMock(side_effect=IndexError)
>>> m(1, 2, 3)
Traceback (most recent call last):
  ...
IndexError
>>> m.mock_calls
[call(1, 2, 3)]
>>> m.side_effect = KeyError('Bang!')
>>> m('two', 'three', 'four')
Traceback (most recent call last):
  ...
KeyError: 'Bang!'
>>> m.mock_calls
[call(1, 2, 3), call('two', 'three', 'four')]

If side_effect is a function then whatever that function returns is whatcalls to the mock return. The side_effect function is called with thesame arguments as the mock. This allows you to vary the return value of thecall dynamically, based on the input:

>>> def side_effect(value):
...     return value + 1
...
>>> m = MagicMock(side_effect=side_effect)
>>> m(1)
2
>>> m(2)
3
>>> m.mock_calls
[call(1), call(2)]

If you want the mock to still return the default return value (a new mock), orany set return value, then there are two ways of doing this. Either returnmock.return_value from inside side_effect, or return DEFAULT:

>>> m = MagicMock()
>>> def side_effect(*args, **kwargs):
...     return m.return_value
...
>>> m.side_effect = side_effect
>>> m.return_value = 3
>>> m()
3
>>> def side_effect(*args, **kwargs):
...     return DEFAULT
...
>>> m.side_effect = side_effect
>>> m()
3

To remove a side_effect, and return to the default behaviour, set theside_effect to None:

>>> m = MagicMock(return_value=6)
>>> def side_effect(*args, **kwargs):
...     return 3
...
>>> m.side_effect = side_effect
>>> m()
3
>>> m.side_effect = None
>>> m()
6

The side_effect can also be any iterable object. Repeated calls to the mockwill return values from the iterable (until the iterable is exhausted anda StopIteration is raised):

>>> m = MagicMock(side_effect=[1, 2, 3])
>>> m()
1
>>> m()
2
>>> m()
3
>>> m()
Traceback (most recent call last):
  ...
StopIteration

If any members of the iterable are exceptions they will be raised instead ofreturned:

>>> iterable = (33, ValueError, 66)
>>> m = MagicMock(side_effect=iterable)
>>> m()
33
>>> m()
Traceback (most recent call last):
 ...
ValueError
>>> m()
66

Deleting Attributes

Mock objects create attributes on demand. This allows them to pretend to beobjects of any type.

You may want a mock object to return False to a hasattr() call, or raise anAttributeError when an attribute is fetched. You can do this by providingan object as a spec for a mock, but that isn't always convenient.

You "block" attributes by deleting them. Once deleted, accessing an attributewill raise an AttributeError.

>>> mock = MagicMock()
>>> hasattr(mock, 'm')
True
>>> del mock.m
>>> hasattr(mock, 'm')
False
>>> del mock.f
>>> mock.f
Traceback (most recent call last):
    ...
AttributeError: f

Mock names and the name attribute

Since "name" is an argument to the Mock constructor, if you want yourmock object to have a "name" attribute you can't just pass it in at creationtime. There are two alternatives. One option is to useconfigure_mock():

>>> mock = MagicMock()
>>> mock.configure_mock(name='my_name')
>>> mock.name
'my_name'

A simpler option is to simply set the "name" attribute after mock creation:

>>> mock = MagicMock()
>>> mock.name = "foo"

Attaching Mocks as Attributes

When you attach a mock as an attribute of another mock (or as the returnvalue) it becomes a "child" of that mock. Calls to the child are recorded inthe method_calls and mock_calls attributes of theparent. This is useful for configuring child mocks and then attaching them tothe parent, or for attaching mocks to a parent that records all calls to thechildren and allows you to make assertions about the order of calls betweenmocks:

>>> parent = MagicMock()
>>> child1 = MagicMock(return_value=None)
>>> child2 = MagicMock(return_value=None)
>>> parent.child1 = child1
>>> parent.child2 = child2
>>> child1(1)
>>> child2(2)
>>> parent.mock_calls
[call.child1(1), call.child2(2)]

The exception to this is if the mock has a name. This allows you to preventthe "parenting" if for some reason you don't want it to happen.

>>> mock = MagicMock()
>>> not_a_child = MagicMock(name='not-a-child')
>>> mock.attribute = not_a_child
>>> mock.attribute()
<MagicMock name='not-a-child()' id='...'>
>>> mock.mock_calls
[]

Mocks created for you by patch() are automatically given names. Toattach mocks that have names to a parent you use the attach_mock()method:

>>> thing1 = object()
>>> thing2 = object()
>>> parent = MagicMock()
>>> with patch('__main__.thing1', return_value=None) as child1:
...     with patch('__main__.thing2', return_value=None) as child2:
...         parent.attach_mock(child1, 'child1')
...         parent.attach_mock(child2, 'child2')
...         child1('one')
...         child2('two')
...
>>> parent.mock_calls
[call.child1('one'), call.child2('two')]

• 1
• The only exceptions are magic methods and attributes (those that haveleading and trailing double underscores). Mock doesn't create these butinstead raises an AttributeError. This is because the interpreterwill often implicitly request these methods, and gets very confused toget a new Mock object when it expects a magic method. If you need magicmethod support see magic methods.

The patchers

The patch decorators are used for patching objects only within the scope ofthe function they decorate. They automatically handle the unpatching for you,even if exceptions are raised. All of these functions can also be used in withstatements or as class decorators.

patch

注解

patch() is straightforward to use. The key is to do the patching in theright namespace. See the section where to patch.

• unittest.mock.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 contextmanager. Inside the body of the function or with statement, the target_is patched with a _new object. When the function/with statement exitsthe patch is undone.

If new is omitted, then the target is replaced with aMagicMock. If patch() is used as a decorator and new isomitted, the created mock is passed in as an extra argument to thedecorated function. If patch() is used as a context manager the createdmock is returned by the context manager.

target should be a string in the form 'package.module.ClassName'. Thetarget is imported and the specified object replaced with the new_object, so the _target must be importable from the environment you arecalling patch() from. The target is imported when the decorated functionis executed, not at decoration time.

The spec and spec_set keyword arguments are passed to the MagicMockif patch is creating one for you.

In addition you can pass spec=True or spec_set=True, which causespatch 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 isused.

A more powerful form of spec is autospec. If you set autospec=Truethen the mock will be created with a spec from the object being replaced.All attributes of the mock will also have the spec of the correspondingattribute of the object being replaced. Methods and functions being mockedwill have their arguments checked and will raise a TypeError if they arecalled with the wrong signature. For mocksreplacing a class, their return value (the 'instance') will have the samespec as the class. See the create_autospec() function andAutospeccing.

Instead of autospec=True you can pass autospec=some_object to use anarbitrary 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 willcreate the attribute for you when the patched function is called, and deleteit again after the patched function has exited. This is useful for writingtests against attributes that your production code creates at runtime. It isoff by default because it can be dangerous. With it switched on you canwrite passing tests against APIs that don't actually exist!

注解

在 3.5 版更改: If you are patching builtins in a module then you don'tneed to pass create=True, it will be added by default.

Patch can be used as a TestCase class decorator. It works bydecorating each test method in the class. This reduces the boilerplatecode when your test methods share a common patchings set. patch() findstests by looking for method names that start with patch.TEST_PREFIX.By default this is 'test', which matches the way unittest finds tests.You can specify an alternative prefix by setting patch.TEST_PREFIX.

Patch can be used as a context manager, with the with statement. Here thepatching applies to the indented block after the with statement. If youuse "as" then the patched object will be bound to the name after the"as"; very useful if patch() is creating a mock object for you.

patch() takes arbitrary keyword arguments. These will be passed tothe Mock (or new_callable) on construction.

patch.dict(…), patch.multiple(…) and patch.object(…) areavailable for alternate use-cases.

patch() as function decorator, creating the mock for you and passing it intothe decorated function:

>>> @patch('__main__.SomeClass')
... def function(normal_argument, mock_class):
...     print(mock_class is SomeClass)
...
>>> function(None)
True

Patching a class replaces the class with a MagicMockinstance. If theclass is instantiated in the code under test then it will be thereturn_value of the mock that will be used.

If the class is instantiated multiple times you could useside_effect to return a new mock each time. Alternatively youcan set the return_value to be anything you want.

To configure return values on methods of instances on the patched classyou must do this on the return_value. For example:

>>> class Class:
...     def method(self):
...         pass
...
>>> with patch('__main__.Class') as MockClass:
...     instance = MockClass.return_value
...     instance.method.return_value = 'foo'
...     assert Class() is instance
...     assert Class().method() == 'foo'
...

If you use spec or spec_set and patch() is replacing a class, then thereturn value of the created mock will have the same spec.

>>> Original = Class
>>> patcher = patch('__main__.Class', spec=True)
>>> MockClass = patcher.start()
>>> instance = MockClass()
>>> assert isinstance(instance, Original)
>>> patcher.stop()

The new_callable argument is useful where you want to use an alternativeclass to the default MagicMock for the created mock. For example, ifyou wanted a NonCallableMock to be used:

>>> thing = object()
>>> with patch('__main__.thing', new_callable=NonCallableMock) as mock_thing:
...     assert thing is mock_thing
...     thing()
...
Traceback (most recent call last):
  ...
TypeError: 'NonCallableMock' object is not callable

Another use case might be to replace an object with an io.StringIO instance:

>>> from io import StringIO
>>> def foo():
...     print('Something')
...
>>> @patch('sys.stdout', new_callable=StringIO)
... def test(mock_stdout):
...     foo()
...     assert mock_stdout.getvalue() == 'Something\n'
...
>>> test()

When patch() is creating a mock for you, it is common that the first thingyou need to do is to configure the mock. Some of that configuration can be donein the call to patch. Any arbitrary keywords you pass into the call will beused to set attributes on the created mock:

>>> patcher = patch('__main__.thing', first='one', second='two')
>>> mock_thing = patcher.start()
>>> mock_thing.first
'one'
>>> mock_thing.second
'two'

As well as attributes on the created mock attributes, like thereturn_value and side_effect, of child mocks canalso be configured. These aren't syntactically valid to pass in directly askeyword arguments, but a dictionary with these as keys can still be expandedinto a patch() call using **:

>>> config = {'method.return_value': 3, 'other.side_effect': KeyError}
>>> patcher = patch('__main__.thing', **config)
>>> mock_thing = patcher.start()
>>> mock_thing.method()
3
>>> mock_thing.other()
Traceback (most recent call last):
  ...
KeyError

By default, attempting to patch a function in a module (or a method or anattribute in a class) that does not exist will fail with AttributeError:

>>> @patch('sys.non_existing_attribute', 42)
... def test():
...     assert sys.non_existing_attribute == 42
...
>>> test()
Traceback (most recent call last):
  ...
AttributeError: <module 'sys' (built-in)> does not have the attribute 'non_existing'

but adding create=True in the call to patch() will make the previous examplework as expected:

>>> @patch('sys.non_existing_attribute', 42, create=True)
... def test(mock_stdout):
...     assert sys.non_existing_attribute == 42
...
>>> test()

patch.object

• 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 mockobject.

patch.object() can be used as a decorator, class decorator or a contextmanager. Arguments new, spec, create, spec_set, autospec andnew_callable have the same meaning as for patch(). Like patch(),patch.object() takes arbitrary keyword arguments for configuring the mockobject it creates.

When used as a class decorator patch.object() honours patch.TEST_PREFIXfor choosing which methods to wrap.

You can either call patch.object() with three arguments or two arguments. Thethree argument form takes the object to be patched, the attribute name and theobject to replace the attribute with.

When calling with the two argument form you omit the replacement object, and amock is created for you and passed in as an extra argument to the decoratedfunction:

>>> @patch.object(SomeClass, 'class_method')
... def test(mock_method):
...     SomeClass.class_method(3)
...     mock_method.assert_called_with(3)
...
>>> test()

spec, create and the other arguments to patch.object() have the samemeaning as they do for patch().

patch.dict

• patch.dict(in_dict, values=(), clear=False, **kwargs)
• Patch a dictionary, or dictionary like object, and restore the dictionaryto its original state after the test.

in_dict can be a dictionary or a mapping like container. If it is amapping then it must at least support getting, setting and deleting itemsplus iterating over keys.

in_dict can also be a string specifying the name of the dictionary, whichwill 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 newvalues are set.

patch.dict() can also be called with arbitrary keyword arguments to setvalues in the dictionary.

patch.dict() can be used as a context manager, decorator or classdecorator. When used as a class decorator patch.dict() honourspatch.TEST_PREFIX for choosing which methods to wrap.

patch.dict() can be used to add members to a dictionary, or simply let a testchange a dictionary, and ensure the dictionary is restored when the testends.

>>> foo = {}
>>> with patch.dict(foo, {'newkey': 'newvalue'}):
...     assert foo == {'newkey': 'newvalue'}
...
>>> assert foo == {}

>>> import os
>>> with patch.dict('os.environ', {'newkey': 'newvalue'}):
...     print(os.environ['newkey'])
...
newvalue
>>> assert 'newkey' not in os.environ

Keywords can be used in the patch.dict() call to set values in the dictionary:

>>> mymodule = MagicMock()
>>> mymodule.function.return_value = 'fish'
>>> with patch.dict('sys.modules', mymodule=mymodule):
...     import mymodule
...     mymodule.function('some', 'args')
...
'fish'

patch.dict() can be used with dictionary like objects that aren't actuallydictionaries. At the very minimum they must support item getting, setting,deleting and either iteration or membership test. This corresponds to themagic methods getitem(), setitem(), delitem() and eitheriter() or contains().

>>> class Container:
...     def __init__(self):
...         self.values = {}
...     def __getitem__(self, name):
...         return self.values[name]
...     def __setitem__(self, name, value):
...         self.values[name] = value
...     def __delitem__(self, name):
...         del self.values[name]
...     def __iter__(self):
...         return iter(self.values)
...
>>> thing = Container()
>>> thing['one'] = 1
>>> with patch.dict(thing, one=2, two=3):
...     assert thing['one'] == 2
...     assert thing['two'] == 3
...
>>> assert thing['one'] == 1
>>> assert list(thing) == ['one']

patch.multiple

• patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)
• Perform multiple patches in a single call. It takes the object to bepatched (either as an object or a string to fetch the object by importing)and keyword arguments for the patches:

with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):
    ...

Use DEFAULT as the value if you want patch.multiple() to createmocks for you. In this case the created mocks are passed into a decoratedfunction by keyword, and a dictionary is returned when patch.multiple() isused as a context manager.

patch.multiple() can be used as a decorator, class decorator or a contextmanager. The arguments spec, spec_set, create, autospec andnew_callable have the same meaning as for patch(). These arguments willbe applied to all patches done by patch.multiple().

When used as a class decorator patch.multiple() honours patch.TEST_PREFIXfor choosing which methods to wrap.

If you want patch.multiple() to create mocks for you, then you can useDEFAULT as the value. If you use patch.multiple() as a decoratorthen the created mocks are passed into the decorated function by keyword.

>>> thing = object()
>>> other = object()

>>> @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
... def test_function(thing, other):
...     assert isinstance(thing, MagicMock)
...     assert isinstance(other, MagicMock)
...
>>> test_function()

patch.multiple() can be nested with other patch decorators, but put argumentspassed by keyword after any of the standard arguments created by patch():

>>> @patch('sys.exit')
... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)
... def test_function(mock_exit, other, thing):
...     assert 'other' in repr(other)
...     assert 'thing' in repr(thing)
...     assert 'exit' in repr(mock_exit)
...
>>> test_function()

If patch.multiple() is used as a context manager, the value returned by thecontext manager is a dictionary where created mocks are keyed by name:

>>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:
...     assert 'other' in repr(values['other'])
...     assert 'thing' in repr(values['thing'])
...     assert values['thing'] is thing
...     assert values['other'] is other
...

patch methods: start and stop

All the patchers have start() and stop() methods. These make it simpler to dopatching in setUp methods or where you want to do multiple patches withoutnesting decorators or with statements.

To use them call patch(), patch.object() or patch.dict() asnormal and keep a reference to the returned patcher object. You can thencall 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 bythe call to patcher.start.

>>> patcher = patch('package.module.ClassName')
>>> from package import module
>>> original = module.ClassName
>>> new_mock = patcher.start()
>>> assert module.ClassName is not original
>>> assert module.ClassName is new_mock
>>> patcher.stop()
>>> assert module.ClassName is original
>>> assert module.ClassName is not new_mock

A typical use case for this might be for doing multiple patches in the setUpmethod of a TestCase:

>>> class MyTest(TestCase):
...     def setUp(self):
...         self.patcher1 = patch('package.module.Class1')
...         self.patcher2 = patch('package.module.Class2')
...         self.MockClass1 = self.patcher1.start()
...         self.MockClass2 = self.patcher2.start()
...
...     def tearDown(self):
...         self.patcher1.stop()
...         self.patcher2.stop()
...
...     def test_something(self):
...         assert package.module.Class1 is self.MockClass1
...         assert package.module.Class2 is self.MockClass2
...
>>> MyTest('test_something').run()

警告

If you use this technique you must ensure that the patching is "undone" bycalling stop. This can be fiddlier than you might think, because if anexception is raised in the setUp then tearDown is not called.unittest.TestCase.addCleanup() makes this easier:

>>> class MyTest(TestCase):
...     def setUp(self):
...         patcher = patch('package.module.Class')
...         self.MockClass = patcher.start()
...         self.addCleanup(patcher.stop)
...
...     def test_something(self):
...         assert package.module.Class is self.MockClass
...

As an added bonus you no longer need to keep a reference to the patcherobject.

It is also possible to stop all patches which have been started by usingpatch.stopall().

• patch.stopall()
• Stop all active patches. Only stops patches started with start.

patch builtins

You can patch any builtins within a module. The following example patchesbuiltin ord():

>>> @patch('__main__.ord')
... def test(mock_ord):
...     mock_ord.return_value = 101
...     print(ord('c'))
...
>>> test()
101

TEST_PREFIX

All of the patchers can be used as class decorators. When used in this waythey wrap every test method on the class. The patchers recognise methods thatstart with 'test' as being test methods. This is the same way that theunittest.TestLoader finds test methods by default.

It is possible that you want to use a different prefix for your tests. You caninform the patchers of the different prefix by setting patch.TEST_PREFIX:

>>> patch.TEST_PREFIX = 'foo'
>>> value = 3
>>>
>>> @patch('__main__.value', 'not three')
... class Thing:
...     def foo_one(self):
...         print(value)
...     def foo_two(self):
...         print(value)
...
>>>
>>> Thing().foo_one()
not three
>>> Thing().foo_two()
not three
>>> value
3

Nesting Patch Decorators

If you want to perform multiple patches then you can simply stack up thedecorators.

You can stack up multiple patch decorators using this pattern:

>>> @patch.object(SomeClass, 'class_method')
... @patch.object(SomeClass, 'static_method')
... def test(mock1, mock2):
...     assert SomeClass.static_method is mock1
...     assert SomeClass.class_method is mock2
...     SomeClass.static_method('foo')
...     SomeClass.class_method('bar')
...     return mock1, mock2
...
>>> mock1, mock2 = test()
>>> mock1.assert_called_once_with('foo')
>>> mock2.assert_called_once_with('bar')

Note that the decorators are applied from the bottom upwards. This is thestandard way that Python applies decorators. The order of the created mockspassed into your test function matches this order.

Where to patch

patch() works by (temporarily) changing the object that a name points to withanother one. There can be many names pointing to any individual object, sofor patching to work you must ensure that you patch the name used by the systemunder test.

The basic principle is that you patch where an object is looked up, whichis not necessarily the same place as where it is defined. A couple ofexamples will help to clarify this.

Imagine we have a project that we want to test with the following structure:

a.py
    -> Defines SomeClass
 
b.py
    -> from a import SomeClass
    -> some_function instantiates SomeClass

Now we want to test somefunction but we want to mock out SomeClass usingpatch(). The problem is that when we import module b, which we will have todo then it imports SomeClass from module a. If we use patch() to mock outa.SomeClass then it will have no effect on our test; module b already has areference to the _real SomeClass and it looks like our patching had noeffect.

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 importSomeClass module b does import a and some_function uses a.SomeClass. Bothof these import forms are common. In this case the class we want to patch isbeing looked up in the module and so we have to patch a.SomeClass instead:

@patch('a.SomeClass')

Patching Descriptors and Proxy Objects

Both patch and patch.object correctly patch and restore descriptors: classmethods, static methods and properties. You should patch these on the class_rather than an instance. They also work with _some objectsthat proxy attribute access, like the django settings object.

MagicMock and magic method support

Mocking Magic Methods

Mock supports mocking the Python protocol methods, also known as"magic methods". This allows mock objects to replace containers or otherobjects that implement Python protocols.

Because magic methods are looked up differently from normal methods 2, thissupport has been specially implemented. This means that only specific magicmethods are supported. The supported list includes almost all of them. Ifthere are any missing that you need please let us know.

You mock magic methods by setting the method you are interested in to a functionor a mock instance. If you are using a function then it must take self asthe first argument 3.

>>> def __str__(self):
...     return 'fooble'
...
>>> mock = Mock()
>>> mock.__str__ = __str__
>>> str(mock)
'fooble'

>>> mock = Mock()
>>> mock.__str__ = Mock()
>>> mock.__str__.return_value = 'fooble'
>>> str(mock)
'fooble'

>>> mock = Mock()
>>> mock.__iter__ = Mock(return_value=iter([]))
>>> list(mock)
[]

One use case for this is for mocking objects used as context managers in awith statement:

>>> mock = Mock()
>>> mock.__enter__ = Mock(return_value='foo')
>>> mock.__exit__ = Mock(return_value=False)
>>> with mock as m:
...     assert m == 'foo'
...
>>> mock.__enter__.assert_called_with()
>>> mock.__exit__.assert_called_with(None, None, None)

Calls to magic methods do not appear in method_calls, but theyare recorded in mock_calls.

注解

If you use the spec keyword argument to create a mock then attempting toset a magic method that isn't in the spec will raise an AttributeError.

The full list of supported magic methods is:

• hash, sizeof, repr and str

• dir, format and subclasses

• floor, trunc and ceil

• Comparisons: lt, gt, le, ge,eq and ne

• Container methods: getitem, setitem, delitem,contains, len, iter, reversedand missing

• Context manager: enter and exit

• Unary numeric methods: neg, pos and invert

• The numeric methods (including right hand and in-place variants):add, sub, mul, matmul, div, truediv,floordiv, mod, divmod, lshift,rshift, and, xor, or, and pow

• Numeric conversion methods: complex, int, floatand index

• Descriptor methods: get, set and delete

• Pickling: reduce, reduce_ex, getinitargs,getnewargs, getstate and setstate

The following methods exist but are not supported as they are either in useby mock, can't be set dynamically, or can cause problems:

• getattr, setattr, init and new

• prepare, instancecheck, subclasscheck, del

Magic Mock

There are two MagicMock variants: MagicMock and NonCallableMagicMock.

• class unittest.mock.MagicMock(*args, **kw)
• MagicMock is a subclass of Mock with default implementationsof most of the magic methods. You can use MagicMock without having toconfigure the magic methods yourself.

The constructor parameters have the same meaning as for Mock.

If you use the spec or spec_set arguments then only magic methodsthat exist in the spec will be created.

• class unittest.mock.NonCallableMagicMock(*args, **kw)
• A non-callable version of MagicMock.

The constructor parameters have the same meaning as forMagicMock, with the exception of return_value andside_effect which have no meaning on a non-callable mock.

The magic methods are setup with MagicMock objects, so you can configure themand use them in the usual way:

>>> mock = MagicMock()
>>> mock[3] = 'fish'
>>> mock.__setitem__.assert_called_with(3, 'fish')
>>> mock.__getitem__.return_value = 'result'
>>> mock[2]
'result'

By default many of the protocol methods are required to return objects of aspecific type. These methods are preconfigured with a default return value, sothat they can be used without you having to do anything if you aren't interestedin the return value. You can still set the return value manually if you wantto change the default.

Methods and their defaults:

• lt: NotImplemented

• gt: NotImplemented

• le: NotImplemented

• ge: NotImplemented

• int: 1

• contains: False

• len: 0

• iter: iter([])

• exit: False

• complex: 1j

• float: 1.0

• bool: True

• index: 1

• hash: default hash for the mock

• str: default str for the mock

• sizeof: default sizeof for the mock

例如:

>>> mock = MagicMock()
>>> int(mock)
1
>>> len(mock)
0
>>> list(mock)
[]
>>> object() in mock
False

The two equality methods, eq() and ne(), are special.They do the default equality comparison on identity, using theside_effect attribute, unless you change their return value toreturn something else:

>>> MagicMock() == 3
False
>>> MagicMock() != 3
True
>>> mock = MagicMock()
>>> mock.__eq__.return_value = True
>>> mock == 3
True

The return value of MagicMock.iter() can be any iterable object and isn'trequired to be an iterator:

>>> mock = MagicMock()
>>> mock.__iter__.return_value = ['a', 'b', 'c']
>>> list(mock)
['a', 'b', 'c']
>>> list(mock)
['a', 'b', 'c']

If the return value is an iterator, then iterating over it once will consumeit and subsequent iterations will result in an empty list:

>>> mock.__iter__.return_value = iter(['a', 'b', 'c'])
>>> list(mock)
['a', 'b', 'c']
>>> list(mock)
[]

MagicMock has all of the supported magic methods configured except for someof the obscure and obsolete ones. You can still set these up if you want.

Magic methods that are supported but not setup by default in MagicMock are:

• subclasses

• dir

• format

• get, set and delete

• reversed and missing

• reduce, reduce_ex, getinitargs, getnewargs,getstate and setstate

• getformat and setformat

• 2

• Magic methods should be looked up on the class rather than theinstance. Different versions of Python are inconsistent about applying thisrule. The supported protocol methods should work with all supported versionsof Python.

• 3

• The function is basically hooked up to the class, but each Mockinstance is kept isolated from the others.

Helpers

sentinel

• unittest.mock.sentinel
• The sentinel object provides a convenient way of providing uniqueobjects for your tests.

Attributes are created on demand when you access them by name. Accessingthe same attribute will always return the same object. The objectsreturned have a sensible repr so that test failure messages are readable.

在 3.7 版更改: The sentinel attributes now preserve their identity when they arecopied or pickled.

Sometimes when testing you need to test that a specific object is passed as anargument to another method, or returned. It can be common to create namedsentinel objects to test this. sentinel provides a convenient way ofcreating and testing the identity of objects like this.

In this example we monkey patch method to return sentinel.some_object:

>>> real = ProductionClass()
>>> real.method = Mock(name="method")
>>> real.method.return_value = sentinel.some_object
>>> result = real.method()
>>> assert result is sentinel.some_object
>>> sentinel.some_object
sentinel.some_object

DEFAULT

• unittest.mock.DEFAULT
• The DEFAULT object is a pre-created sentinel (actuallysentinel.DEFAULT). It can be used by side_effectfunctions to indicate that the normal return value should be used.

call

• unittest.mock.call(*args, **kwargs)
• call() is a helper object for making simpler assertions, for comparing withcall_args, call_args_list,mock_calls and method_calls. call() can also beused with assert_has_calls().

>>> m = MagicMock(return_value=None)
>>> m(1, 2, a='foo', b='bar')
>>> m()
>>> m.call_args_list == [call(1, 2, a='foo', b='bar'), call()]
True

• call.call_list()
• For a call object that represents multiple calls, call_list()returns a list of all the intermediate calls as well as thefinal call.

call_list is particularly useful for making assertions on "chained calls". Achained call is multiple calls on a single line of code. This results inmultiple entries in mock_calls on a mock. Manually constructingthe sequence of calls can be tedious.

call_list() can construct the sequence of calls from the samechained call:

>>> m = MagicMock()
>>> m(1).method(arg='foo').other('bar')(2.0)
<MagicMock name='mock().method().other()()' id='...'>
>>> kall = call(1).method(arg='foo').other('bar')(2.0)
>>> kall.call_list()
[call(1),
 call().method(arg='foo'),
 call().method().other('bar'),
 call().method().other()(2.0)]
>>> m.mock_calls == kall.call_list()
True

A call object is either a tuple of (positional args, keyword args) or(name, positional args, keyword args) depending on how it was constructed. Whenyou construct them yourself this isn't particularly interesting, but the callobjects that are in the Mock.call_args, Mock.call_args_list andMock.mock_calls attributes can be introspected to get at the individualarguments they contain.

The call objects in Mock.call_args and Mock.call_args_listare two-tuples of (positional args, keyword args) whereas the call objectsin Mock.mock_calls, along with ones you construct yourself, arethree-tuples of (name, positional args, keyword args).

You can use their "tupleness" to pull out the individual arguments for morecomplex introspection and assertions. The positional arguments are a tuple(an empty tuple if there are no positional arguments) and the keywordarguments are a dictionary:

>>> m = MagicMock(return_value=None)
>>> m(1, 2, 3, arg='one', arg2='two')
>>> kall = m.call_args
>>> args, kwargs = kall
>>> args
(1, 2, 3)
>>> kwargs
{'arg2': 'two', 'arg': 'one'}
>>> args is kall[0]
True
>>> kwargs is kall[1]
True

>>> m = MagicMock()
>>> m.foo(4, 5, 6, arg='two', arg2='three')
<MagicMock name='mock.foo()' id='...'>
>>> kall = m.mock_calls[0]
>>> name, args, kwargs = kall
>>> name
'foo'
>>> args
(4, 5, 6)
>>> kwargs
{'arg2': 'three', 'arg': 'two'}
>>> name is m.mock_calls[0][0]
True

create_autospec

• unittest.mock.createautospec(_spec, spec_set=False, instance=False, **kwargs)
• Create a mock object using another object as a spec. Attributes on themock will use the corresponding attribute on the spec object as theirspec.

Functions or methods being mocked will have their arguments checked toensure that they are called with the correct signature.

If spec_set is True then attempting to set attributes that don't existon the spec object will raise an AttributeError.

If a class is used as a spec then the return value of the mock (theinstance of the class) will have the same spec. You can use a class as thespec for an instance object by passing instance=True. The returned mockwill only be callable if instances of the mock are callable.

create_autospec() also takes arbitrary keyword arguments that are passed tothe constructor of the created mock.

See Autospeccing for examples of how to use auto-speccing withcreate_autospec() and the autospec argument to patch().

ANY

• unittest.mock.ANY

Sometimes you may need to make assertions about some of the arguments in acall to mock, but either not care about some of the arguments or want to pullthem individually out of call_args and make more complexassertions on them.

To ignore certain arguments you can pass in objects that compare equal toeverything. Calls to assert_called_with() andassert_called_once_with() will then succeed no matter what waspassed in.

>>> mock = Mock(return_value=None)
>>> mock('foo', bar=object())
>>> mock.assert_called_once_with('foo', bar=ANY)

ANY can also be used in comparisons with call lists likemock_calls:

>>> m = MagicMock(return_value=None)
>>> m(1)
>>> m(1, 2)
>>> m(object())
>>> m.mock_calls == [call(1), call(1, 2), ANY]
True

FILTER_DIR

• unittest.mock.FILTER_DIR

FILTER_DIR is a module level variable that controls the way mock objectsrespond to 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 youdislike this filtering, or need to switch it off for diagnostic purposes, thenset mock.FILTER_DIR = False.

With filtering on, dir(somemock) shows only useful attributes and willinclude any dynamically created attributes that wouldn't normally be shown.If the mock was created with a _spec (or autospec of course) then all theattributes from the original are shown, even if they haven't been accessedyet:

>>> dir(Mock())
['assert_any_call',
 'assert_called_once_with',
 'assert_called_with',
 'assert_has_calls',
 'attach_mock',
 ...
>>> from urllib import request
>>> dir(Mock(spec=request))
['AbstractBasicAuthHandler',
 'AbstractDigestAuthHandler',
 'AbstractHTTPHandler',
 'BaseHandler',
 ...

Many of the not-very-useful (private to Mock rather than the thing beingmocked) underscore and double underscore prefixed attributes have beenfiltered from the result of calling dir() on a Mock. If you dislike thisbehaviour you can switch it off by setting the module level switchFILTER_DIR:

>>> from unittest import mock
>>> mock.FILTER_DIR = False
>>> dir(mock.Mock())
['_NonCallableMock__get_return_value',
 '_NonCallableMock__get_side_effect',
 '_NonCallableMock__return_value_doc',
 '_NonCallableMock__set_return_value',
 '_NonCallableMock__set_side_effect',
 '__call__',
 '__class__',
 ...

Alternatively you can just use vars(my_mock) (instance members) anddir(type(my_mock)) (type members) to bypass the filtering irrespective ofmock.FILTER_DIR.

mock_open

• unittest.mock.mockopen(_mock=None, read_data=None)
• A helper function to create a mock to replace the use of open(). It worksfor open() called directly or used as a context manager.

The mock argument is the mock object to configure. If None (thedefault) then a MagicMock will be created for you, with the API limitedto methods or attributes available on standard file handles.

read_data is a string for the read(),readline(), and readlines() methodsof the file handle to return. Calls to those methods will take data fromread_data until it is depleted. The mock of these methods is prettysimplistic: every time the mock is called, the read_data is rewound tothe start. If you need more control over the data that you are feeding tothe tested code you will need to customize this mock for yourself. When thatis insufficient, one of the in-memory filesystem packages on PyPI can offer a realistic filesystem for testing.

在 3.4 版更改: Added readline() and readlines() support.The mock of read() changed to consume read_data ratherthan returning it on each call.

在 3.5 版更改: read_data is now reset on each call to the mock.

在 3.7.1 版更改: Added iter() to implementation so that iteration (such as in forloops) correctly consumes read_data.

Using open() as a context manager is a great way to ensure your file handlesare 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 thereturned object that is used as a context manager (and has enter() andexit() called).

Mocking context managers with a MagicMock is common enough and fiddlyenough that a helper function is useful.

>>> m = mock_open()
>>> with patch('__main__.open', m):
...     with open('foo', 'w') as h:
...         h.write('some stuff')
...
>>> m.mock_calls
[call('foo', 'w'),
 call().__enter__(),
 call().write('some stuff'),
 call().__exit__(None, None, None)]
>>> m.assert_called_once_with('foo', 'w')
>>> handle = m()
>>> handle.write.assert_called_once_with('some stuff')