Pythonunittest.mock模拟对象库

快速上手¶

当您访问对象时， Mock 和 MagicMock 将创建所有属性和方法，并保存他们在使用时的细节。你可以通过配置，指定返回值或者限制可访问属性，然后断言他们如何被调用。

>>> fromunittest.mockimportMagicMock
>>> 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 设置副作用(side effects) ，可以是一个 mock 被调用是抛出的异常

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

>>> values={'a':1,'b':2,'c':3}
>>> defside_effect(arg):
... returnvalues[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 还可以通过其他方法配置和控制其行为。例如 mock 可以通过设置 spec 参数来从一个对象中获取其规格(specification)。如果访问 mock 的属性或方法不在 spec 中，会报 AttributeError 错误。

The 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

mock (or other object) during the test and restored when the test ends:

>>> fromunittest.mockimportpatch
>>> @patch('module.ClassName2')
... @patch('module.ClassName1')
... deftest(MockClass1,MockClass2):
... module.ClassName1()
... module.ClassName2()
... assertMockClass1ismodule.ClassName1
... assertMockClass2ismodule.ClassName2
... assertMockClass1.called
... assertMockClass2.called
...
>>> test()

patch() 也可以 with 语句中使用上下文管理。

>>> withpatch.object(ProductionClass,'method',return_value=None)asmock_method:
... thing=ProductionClass()
... thing.method(1,2,3)
...
>>> mock_method.assert_called_once_with(1,2,3)

还有一个 patch.dict() 用于在一定范围内设置字典中的值，并在测试结束时将字典恢复为其原始状态：

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

Mock支持 Python 魔术方法 。使用模式方法最简单的方式是使用 MagicMock class. 。它可以做如下事情：

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

Mock 能指定函数（或其他 Mock 实例）为魔术方法，它们将被适当地调用。 MagicMock 是预先创建了所有魔术方法（所有有用的方法） 的 Mock 。

下面是一个使用了普通 Mock 类的魔术方法的例子

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

使用 auto-speccing 可以保证测试中的模拟对象与要替换的对象具有相同的api 。在 patch 中可以通过 autospec 参数实现自动推断，或者使用 create_autospec() 函数。自动推断会创建一个与要替换对象相同的属相和方法的模拟对象，并且任何函数和方法（包括构造函数）都具有与真实对象相同的调用签名。

这么做是为了因确保不当地使用 mock 导致与生产代码相同的失败：

>>> fromunittest.mockimportcreate_autospec
>>> deffunction(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() 时，会复制 __init__ 的签名，另外在可调用对象上使用时，会复制 __call__ 的签名。

Mock 类¶

Mock 是一个可以灵活的替换存根 (stubs) 的对象，可以测试所有代码。 Mock 是可调用的，在访问其属性时创建一个新的 mock 1 。访问相同的属性只会返回相同的 mock 。 Mock 保存调用记录，可以通过断言获悉代码的调用。

MagicMock 是 Mock 的子类，它有所有预创建且可使用的魔术方法。在需要模拟不可调用对象时，可以使用 NonCallableMock  和 NonCallableMagicMock

patch() 装饰器使得用 Mock 对象临时替换特定模块中的类非常方便。 默认情况下 patch() 将为你创建一个 MagicMock。 你可以使用 patch() 的 new_callable 参数指定替代 Mock 的类。

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

创建一个新的 Mock 对象。通过可选参数指定 Mock 对象的行为：

• spec: 可以是要给字符串列表，也可以是充当模拟对象规范的现有对象（类或实例）。如果传入一个对象，则通过在该对象上调用 dir 来生成字符串列表（不支持的魔法属性和方法除外）。访问不在此列表中的任何属性都将引发 AttributeError 。

  如果 spec 是一个对象（而不是字符串列表），则 __class__ 返回 spec 对象的类。 这允许模拟程序通过 isinstance() 测试。

• spec_set ：spec 的更严格的变体。如果使用了该属性，尝试模拟 set 或 get 的属性不在 spec_set 所包含的对象中时，会抛出 AttributeError 。

• side_effect ：每当调用 Mock 时都会调用的函数。 参见 side_effect 属性。 对于引发异常或动态更改返回值很有用。 该函数使用与 mock 函数相同的参数调用，并且除非返回 DEFAULT ，否则该函数的返回值将用作返回值。

  另外， side_effect 可以是异常类或实例。 此时，调用模拟程序时将引发异常。

  如果 side_effect 是可迭代对象，则每次调用 mock 都将返回可迭代对象的下一个值。

  设置 side_effect 为 None 即可清空。

• return_value ：调用 mock 的返回值。 默认情况下，是一个新的Mock（在首次访问时创建）。 参见 return_value 属性 。

• unsafe ：默认情况下，如果任何以 assert 或 assret 开头的属性都将引发 AttributeError 。 当 unsafe=True 时可以访问。

  3.5 新版功能.

• wraps ：要包装的 mock 对象。 如果 wraps 不是 None ，那么调用 Mock 会将调用传递给 wraps 的对象（返回实际结果）。 对模拟的属性访问将返回一个 Mock 对象，该对象包装了 wraps 对象的相应属性（因此，尝试访问不存在的属性将引发 AttributeError ）。

  如果该 mock 明确指定 return_value ，调用是，不会返回包装对象，而是返回 return_value 。

• name ：mock 的名称。 在调试时很有用。 名称会传递到子 mock 。

还可以使用任意关键字参数来调用 mock 。 创建模拟后，将使用这些属性来设置 mock 的属性。 有关详细信息，请参见 configure_mock() 方法。

assert_called()¶

断言该 mock 至少被调用过一次。

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

3.6 新版功能.

assert_called_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 新版功能.

assert_called_with(*args, **kwargs)¶

This method is a convenient way of asserting that calls are made in a

particular 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')

assert_called_once_with(*args, **kwargs)¶

断言仅被调用一次，并且该调用是使用指定的参数进行的。

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

assert_any_call(*args, **kwargs)¶

断言使用指定的参数调用。

The assert passes if the mock has ever been called, unlike

assert_called_with() and assert_called_once_with() that

only pass if the call is the most recent one, and in the case of

assert_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')

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 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

they 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 新版功能.

reset_mock(*, 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 that

reuse the same object. Note that reset_mock()doesn't clear the

return value, side_effect or any child attributes you have

set using normal assignment by default. In case you want to reset

return_value or side_effect, then pass the corresponding

parameter as True. Child mocks and the return value mock

(if any) are reset as well.

注解

return_value, and side_effect are keyword only

argument.

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

attributes from the mock.

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

attach_mock(mock, attribute)¶

Attach a mock as an attribute of this one, replacing its name and

parent. Calls to the attached mock will be recorded in the

method_calls and mock_calls attributes of this one.

configure_mock(**kwargs)¶

Set attributes on the mock through keyword arguments.

Attributes plus return values and side effects can be set on child

mocks using standard dot notation and unpacking a dictionary in the

method 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 configuration

after the mock has been created.

__dir__()¶

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 FILTER_DIR for what this filtering does, and how to

switch 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 way

child mocks are made.

For non-callable mocks the callable variant will be used (rather than

any 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 in

the 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 the

mock and unless the function returns the DEFAULT singleton the

call to the mock will then return whatever the function returns. If the

function returns DEFAULT then the mock will return its normal

value (from the return_value).

If you pass in an iterable, it is used to retrieve an iterator which

must yield a value on every call. This value can either be an exception

instance to be raised, or a value to be returned from the call to the

mock (DEFAULT handling is identical to the function case).

An example of a mock that raises an exception (to test exception

handling 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)
>>> defside_effect(*args,**kwargs):
... returnDEFAULT
...
>>> mock.side_effect=side_effect
>>> mock()
3

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=lambdavalue: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 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

keyword 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 individual

arguments and make more complex assertions. See

calls 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 been

called). Before any calls have been made it is an empty list. The

call object can be used for conveniently constructing lists of

calls 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 be

unpacked as tuples to get at the individual arguments. See

calls as tuples.

method_calls¶

As well as tracking calls to themselves, mocks also track calls to

methods 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 be

unpacked as tuples to get at the individual arguments. See

calls 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 be

unpacked as tuples to get at the individual arguments. See

calls as tuples.

注解

The way mock_calls are recorded means that where nested

calls are made, the parameters of ancestor calls are not recorded

and 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 class

instead. This allows mock objects to pass 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:

>>> 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 same

meaning 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 or

spec_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 magic

methods for the full details.

The mock classes and the patch() decorators all take arbitrary keyword

arguments for configuration. For the patch() decorators the keywords are

passed to the constructor of the mock being created. The keyword arguments

are 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 you

have 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) will

introspect the specification object's signature when matching calls to

the mock. Therefore, it can match the actual call's arguments regardless

of whether they were passed positionally or by name:

>>> deff(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() and

assert_any_call(). When Autospeccing, it will also

apply 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__() methods

so you can specify a return value when it is fetched.

Fetching a PropertyMock instance from an object calls the mock, with

no args. Setting it calls the mock with the value being set.

>>> classFoo:
... @property
... deffoo(self):
... return'something'
... @foo.setter
... deffoo(self,value):
... pass
...
>>> withpatch('__main__.Foo.foo',new_callable=PropertyMock)asmock_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 a

PropertyMock to a mock object. Instead you can attach it to the mock type

object:

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

>>> 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')]

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

>>> m=MagicMock()
>>> defside_effect(*args,**kwargs):
... returnm.return_value
...
>>> m.side_effect=side_effect
>>> m.return_value=3
>>> m()
3
>>> defside_effect(*args,**kwargs):
... returnDEFAULT
...
>>> m.side_effect=side_effect
>>> m()
3

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

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

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

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

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

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

>>> 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)]

>>> 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
[]

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

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

>>> classClass:
... defmethod(self):
... pass
...
>>> withpatch('__main__.Class')asMockClass:
... instance=MockClass.return_value
... instance.method.return_value='foo'
... assertClass()isinstance
... assertClass().method()=='foo'
...

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

>>> thing=object()
>>> withpatch('__main__.thing',new_callable=NonCallableMock)asmock_thing:
... assertthingismock_thing
... thing()
...
Traceback (most recent call last):
...
TypeError: 'NonCallableMock' object is not callable

>>> fromioimportStringIO
>>> deffoo():
... print('Something')
...
>>> @patch('sys.stdout',new_callable=StringIO)
... deftest(mock_stdout):
... foo()
... assertmock_stdout.getvalue()=='Something\n'
...
>>> test()

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

>>> 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

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

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

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

>>> foo={}
>>> withpatch.dict(foo,{'newkey':'newvalue'}):
... assertfoo=={'newkey':'newvalue'}
...
>>> assertfoo=={}

>>> importos
>>> withpatch.dict('os.environ',{'newkey':'newvalue'}):
... print(os.environ['newkey'])
...
newvalue
>>> assert'newkey'notinos.environ

>>> mymodule=MagicMock()
>>> mymodule.function.return_value='fish'
>>> withpatch.dict('sys.modules',mymodule=mymodule):
... importmymodule
... mymodule.function('some','args')
...
'fish'

>>> classContainer:
... def__init__(self):
... self.values={}
... def__getitem__(self,name):
... returnself.values[name]
... def__setitem__(self,name,value):
... self.values[name]=value
... def__delitem__(self,name):
... delself.values[name]
... def__iter__(self):
... returniter(self.values)
...
>>> thing=Container()
>>> thing['one']=1
>>> withpatch.dict(thing,one=2,two=3):
... assertthing['one']==2
... assertthing['two']==3
...
>>> assertthing['one']==1
>>> assertlist(thing)==['one']

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

>>> @patch.multiple('__main__',thing=DEFAULT,other=DEFAULT)
... deftest_function(thing,other):
... assertisinstance(thing,MagicMock)
... assertisinstance(other,MagicMock)
...
>>> test_function()

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

>>> withpatch.multiple('__main__',thing=DEFAULT,other=DEFAULT)asvalues:
... assert'other'inrepr(values['other'])
... assert'thing'inrepr(values['thing'])
... assertvalues['thing']isthing
... assertvalues['other']isother
...

>>> patcher=patch('package.module.ClassName')
>>> frompackageimportmodule
>>> original=module.ClassName
>>> new_mock=patcher.start()
>>> assertmodule.ClassNameisnotoriginal
>>> assertmodule.ClassNameisnew_mock
>>> patcher.stop()
>>> assertmodule.ClassNameisoriginal
>>> assertmodule.ClassNameisnotnew_mock

>>> classMyTest(TestCase):
... defsetUp(self):
... self.patcher1=patch('package.module.Class1')
... self.patcher2=patch('package.module.Class2')
... self.MockClass1=self.patcher1.start()
... self.MockClass2=self.patcher2.start()
...
... deftearDown(self):
... self.patcher1.stop()
... self.patcher2.stop()
...
... deftest_something(self):
... assertpackage.module.Class1isself.MockClass1
... assertpackage.module.Class2isself.MockClass2
...
>>> MyTest('test_something').run()

>>> classMyTest(TestCase):
... defsetUp(self):
... patcher=patch('package.module.Class')
... self.MockClass=patcher.start()
... self.addCleanup(patcher.stop)
...
... deftest_something(self):
... assertpackage.module.Classisself.MockClass
...

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

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

>>> @patch.object(SomeClass,'class_method')
... @patch.object(SomeClass,'static_method')
... deftest(mock1,mock2):
... assertSomeClass.static_methodismock1
... assertSomeClass.class_methodismock2
... SomeClass.static_method('foo')
... SomeClass.class_method('bar')
... returnmock1,mock2
...
>>> mock1,mock2=test()
>>> mock1.assert_called_once_with('foo')
>>> mock2.assert_called_once_with('bar')

a.py
->DefinesSomeClass
b.py
->fromaimportSomeClass
->some_functioninstantiatesSomeClass

@patch('b.SomeClass')

@patch('a.SomeClass')

>>> 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)
[]

>>> mock=Mock()
>>> mock.__enter__=Mock(return_value='foo')
>>> mock.__exit__=Mock(return_value=False)
>>> withmockasm:
... assertm=='foo'
...
>>> mock.__enter__.assert_called_with()
>>> mock.__exit__.assert_called_with(None,None,None)

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

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

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

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

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