unittest.mock — библиотека объектов-заглушек

Вызов

Объекты Mock вызываемы. Вызов вернёт значение, установленное в качестве атрибута return_value. Значение по умолчанию — новый объект Mock; он создаётся в первый раз, когда значение возврата используется (явно или при вызове Mock) — но он хранится и возвращается каждый раз.

Вызовы объекта будут записаны в атрибуты, такие как call_args и call_args_list.

Если установлен side_effect, он будет вызван после того, как вызов будет записан, поэтому, если side_effect вызывает исключение, вызов всё равно записывается.

Самый простой способ заставить мок вызывать исключение при вызове — сделать side_effect классом исключения или экземпляром:

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

Если side_effect является функцией, то то, что возвращает эта функция, и есть то, что возвращают вызовы мока. Функция side_effect вызывается с теми же аргументами, что и мок. Это позволяет динамически изменять значение возврата вызова в зависимости от входных данных:

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

Если вы хотите, чтобы мок всё ещё возвращал значение по умолчанию (новый мок) или любое заданное значение возврата, есть два способа. Либо вернуть return_value изнутри side_effect, либо вернуть 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

Чтобы удалить side_effect и вернуться к стандартному поведению, установите side_effect в значение 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

Также side_effect может быть любым итерируемым объектом. Повторные вызовы мока будут возвращать значения из итерируемого объекта (пока итерируемый объект не исчерпан и не возникает StopIteration):

>>> 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 создают атрибуты по запросу. Это позволяет им имитировать объекты любого типа.

Вам может понадобиться, чтобы объект мока возвращал False в вызове hasattr() или поднимал AttributeError, когда запрашивается атрибут. Вы можете сделать это, предоставив объект в качестве spec для мока, но это не всегда удобно.

Вы «блокируете» атрибуты, удаляя их. После удаления обращение к атрибуту вызовет 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

Имена моков и атрибут name

Поскольку «name» является аргументом конструктора Mock, если вы хотите, чтобы ваш объект мока имел атрибут «name», вы не можете просто передать его при создании. Есть два варианта. Один вариант — использовать configure_mock():

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

Более простой вариант — просто установить атрибут «name» после создания мока:

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

Прикрепление моков в качестве атрибутов

Когда вы прикрепляете мок в качестве атрибута другого мока (или в качестве значения возврата), он становится «ребёнком» этого мока. Вызовы ребёнка записываются в атрибутах method_calls и mock_calls родителя. Это полезно для настройки дочерних моков и их прикрепления к родителю, или для прикрепления моков к родителю, который записывает все вызовы детей и позволяет делать утверждения о порядке вызовов между моками:

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

Моки, созданные для вас patch(), автоматически получают имена. Чтобы прикрепить моки с именами к родителю, используйте метод attach_mock():

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

patch

unittest.mock.patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

patch() действует как декоратор функции, декоратор класса или менеджер контекста. Внутри тела функции или оператора with, target заменяется на new объект. Когда функция/оператор with завершает выполнение, патчинг отменяется.

Если new опущено, то target заменяется на AsyncMock, если заменяемый объект является асинхронной функцией, или на MagicMock в противном случае. Если patch() используется как декоратор и new опущено, созданный mock передается в качестве дополнительного аргумента декорированной функции. Если patch() используется как менеджер контекста, созданный mock возвращается менеджером контекста.

target должно быть строкой в формате 'package.module.ClassName'. target импортируется, и указанный объект заменяется на new объект, поэтому target должен быть импортируемым из среды, откуда вы вызываете patch(). target импортируется во время выполнения декорированной функции, а не во время декорирования.

Ключевые аргументы spec и spec_set передаются в MagicMock, если patch создаёт его для вас.

Кроме того, вы можете передать spec=True или spec_set=True, что заставляет patch передавать объект, подвергаемый моккированию, как объект spec/spec_set.

new_callable позволяет указать другой класс или вызываемый объект, который будет вызван для создания new объекта. По умолчанию используется AsyncMock для асинхронных функций и MagicMock для остальных.

Более мощной формой spec является autospec. Если вы установите autospec=True, то mock будет создан со спецификацией из заменяемого объекта. Все атрибуты mock также будут иметь спецификацию соответствующего атрибута заменяемого объекта. Методы и функции, подвергаемые моккированию, будут проверять свои аргументы и генерировать TypeError, если они вызываются с неправильной сигнатурой. Для моков, заменяющих класс, их возвращаемое значение («экземпляр») будет иметь ту же спецификацию, что и класс. См. функцию create_autospec() и Автоспецификация.

Вместо autospec=True вы можете передать autospec=some_object для использования произвольного объекта в качестве спецификации вместо заменяемого.

По умолчанию patch() не будет заменять атрибуты, которых не существует. Если вы передаете create=True, и атрибут не существует, patch создаст этот атрибут при вызове патченой функции и удалит его после завершения патченой функции. Это полезно для написания тестов на атрибуты, которые ваше производственное кода создаёт во время выполнения. Оно отключено по умолчанию, так как может быть опасно. Включив его, вы можете писать проходящие тесты на API, которые фактически не существуют!

Примечание

Изменено в версии 3.5: Если вы патчите встроенные функции в модуле, то вам не нужно передавать create=True, оно будет добавлено по умолчанию.

Patch может использоваться как декоратор класса TestCase. Он работает, декорируя каждый тестовый метод в классе. Это уменьшает объём кода, когда ваши тестовые методы используют общий набор патчингов. patch() находит тесты, ища имена методов, начинающиеся с patch.TEST_PREFIX. По умолчанию это 'test', что соответствует тому, как unittest находит тесты. Вы можете указать альтернативный префикс, установив patch.TEST_PREFIX.

Patch может использоваться как менеджер контекста с оператором with. Здесь патчинг применяется к отступом блоку кода после оператора with. Если вы используете «as», то патченый объект будет привязан к имени после «as»; очень полезно, если patch() создаёт объект mock для вас.

patch() принимает произвольные ключевые аргументы. Эти аргументы будут переданы в AsyncMock, если заменяемый объект является асинхронным, в MagicMock в противном случае, или в new_callable, если указано.

patch.dict(...), patch.multiple(...) и patch.object(...) доступны для альтернативных случаев использования.

patch() в качестве декоратора функции, создавая mock для вас и передавая его в декорированную функцию:

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

Замена класса подменяет класс на MagicMock экземпляр. Если класс инициализируется в тестируемом коде, то будет использован return_value mock.

Если класс инициализируется несколько раз, вы можете использовать side_effect для возврата нового mock каждый раз. В качестве альтернативы, вы можете установить return_value на любое значение.

Для настройки значений возврата методов экземпляров в заменённом классе, вы должны сделать это в return_value. Например:

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

Если вы используете spec или spec_set, и patch() заменяет класс, то возвращаемое значение созданного mock будет иметь ту же спецификацию.

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

Аргумент new_callable полезен, когда вы хотите использовать альтернативный класс вместо стандартного MagicMock для созданного mock. Например, если вы хотели использовать NonCallableMock:

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

Другим случаем использования может быть замена объекта на экземпляр io.StringIO:

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

Когда patch() создаёт mock для вас, обычно первым делом нужно настроить этот mock. Часть этой настройки может быть сделана в вызове patch. Любые произвольные ключевые слова, которые вы передадите в вызов, будут использоваться для установки атрибутов созданного mock:

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

Помимо атрибутов созданного mock, такие как return_value и side_effect, атрибуты дочерних mock также могут быть настроены. Эти атрибуты не являются синтаксически корректными для непосредственной передачи в качестве аргументов ключевого слова, но словарь с этими ключами всё ещё может быть развёрнут в вызов patch() с помощью **:

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

По умолчанию попытка патчить функцию в модуле (или метод или атрибут в классе), которая не существует, завершится ошибкой 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_attribute'

но добавление create=True в вызов patch() позволит предыдущему примеру работать как ожидается:

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

Заменить указанный член (атрибут) объекта (target) на объект-заглушку.

patch.object() может использоваться как декоратор, декоратор класса или менеджер контекста. Аргументы new, spec, create, spec_set, autospec и new_callable имеют такое же значение, как и для patch(). Как и patch(), patch.object() принимает произвольные ключевые аргументы для настройки создаваемого объекта-заглушки.

При использовании в качестве декоратора класса patch.object() учитывает patch.TEST_PREFIX для выбора методов, которые нужно обернуть.

Вы можете вызвать patch.object() с тремя аргументами или двумя. В форме с тремя аргументами указывается объект, подлежащий замене, имя атрибута и объект, которым нужно заменить атрибут.

При вызове с двумя аргументами вы опускаете объект-замену, и для вас создаётся заглушка, которая передаётся в качестве дополнительного аргумента декорированной функции:

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

spec, create и другие аргументы patch.object() имеют то же значение, что и для patch().

patch.dict

patch.dict(in_dict, values=(), clear=False, **kwargs)

Заменяет словарь или объект, подобный словарю, и восстанавливает словарь в исходное состояние после теста.

in_dict может быть словарем или контейнером, подобным отображению. Если это отображение, то оно должно поддерживать, по крайней мере, получение, установку и удаление элементов, а также итерацию по ключам.

in_dict также может быть строкой, указывающей имя словаря, которое затем будет получено путём импорта.

values может быть словарем значений, которые нужно установить в словаре. values также может быть итерируемым объектом пар (key, value).

Если clear имеет значение True, то словарь будет очищен перед установкой новых значений.

patch.dict() также может вызываться с произвольными ключевыми аргументами для установки значений в словаре.

Изменено в версии 3.8: patch.dict() теперь возвращает изменённый словарь при использовании в качестве менеджера контекста.

patch.dict() может использоваться в качестве менеджера контекста, декоратора или декоратора класса:

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

При использовании в качестве декоратора класса patch.dict() учитывает patch.TEST_PREFIX (по умолчанию 'test') для выбора методов, которые нужно обернуть:

>>> import os
>>> import unittest
>>> from unittest.mock import patch
>>> @patch.dict('os.environ', {'newkey': 'newvalue'})
... class TestSample(unittest.TestCase):
...     def test_sample(self):
...         self.assertEqual(os.environ['newkey'], 'newvalue')

Если вы хотите использовать другой префикс для своих тестов, вы можете сообщить об этом патчеру, задав patch.TEST_PREFIX. Более подробная информация о том, как изменить значение, находится в TEST_PREFIX.

patch.dict() может использоваться для добавления элементов в словарь или просто для изменения словаря в ходе теста, а также для гарантии восстановления словаря по завершении теста.

>>> foo = {}
>>> with patch.dict(foo, {'newkey': 'newvalue'}) as patched_foo:
...     assert foo == {'newkey': 'newvalue'}
...     assert patched_foo == {'newkey': 'newvalue'}
...     # You can add, update or delete keys of foo (or patched_foo, it's the same dict)
...     patched_foo['spam'] = 'eggs'
...
>>> assert foo == {}
>>> assert patched_foo == {}

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

Ключевые слова могут использоваться в вызове patch.dict() для установки значений в словаре:

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

patch.dict() может использоваться с объектами, подобными словарям, которые на самом деле не являются словарями. По меньшей мере, они должны поддерживать получение, установку, удаление элементов и итерацию или проверку принадлежности. Это соответствует магическим методам __getitem__(), __setitem__(), __delitem__() и либо __iter__(), либо __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)

Выполняет несколько замен в одном вызове. Принимает объект, подлежащий замене (либо как объект, либо как строку для получения объекта путём импорта), и ключевые аргументы для замен:

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

Используйте DEFAULT в качестве значения, если вы хотите, чтобы patch.multiple() создавал заглушки для вас. В этом случае созданные заглушки передаются в декорированную функцию по ключевому слову, а словарь возвращается, когда patch.multiple() используется в качестве менеджера контекста.

patch.multiple() может использоваться как декоратор, декоратор класса или менеджер контекста. Аргументы spec, spec_set, create, autospec и new_callable имеют то же значение, что и для patch(). Эти аргументы будут применяться ко всем заменам, сделанным patch.multiple().

При использовании в качестве декоратора класса patch.multiple() учитывает patch.TEST_PREFIX для выбора методов, которые нужно обернуть.

Если вы хотите, чтобы patch.multiple() создавал заглушки для вас, вы можете использовать DEFAULT в качестве значения. Если вы используете patch.multiple() в качестве декоратора, то созданные заглушки передаются в декорированную функцию по ключевому слову.

>>> 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() можно вкладывать в другие patch декораторы, но аргументы, передаваемые по ключевому слову, должны располагаться после любых стандартных аргументов, созданных 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()

Если patch.multiple() используется в качестве менеджера контекста, возвращаемое значение менеджера контекста — словарь, где созданные заглушки являются ключами:

>>> 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: start и stop

Все патчеры имеют методы start() и stop(). Они упрощают работу с заменами в методах setUp или там, где вам нужно выполнить несколько замен без вложенных декораторов или инструкций with.

Для их использования вызовите patch(), patch.object() или patch.dict() как обычно и сохраните ссылку на возвращённый patcher объект. Затем вы можете вызвать start() для размещения замены и stop() для её отмены.

Если вы используете patch() для создания заглушки, то она будет возвращена по вызову 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

Типичный пример использования — выполнение нескольких замен в методе setUp класса TestCase:

>>> class MyTest(unittest.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()

>>> class MyTest(unittest.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
...

Также можно остановить все начатые замены с помощью patch.stopall().

patch.stopall()

Остановить все активные замены. Останавливает только те замены, которые были начаты с помощью start.

патч встроенных функций

Вы можете изменить любые встроенные функции в модуле. Следующий пример патчит встроенную функцию ord():

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

TEST_PREFIX

Все патчеры могут использоваться как декораторы классов. При таком использовании они обертывают каждый тестовый метод в классе. Патчеры распознают методы, начинающиеся с 'test' как тестовые методы. Это тот же способ, которым unittest.TestLoader находит тестовые методы по умолчанию.

Возможно, вы захотите использовать другой префикс для своих тестов. Вы можете сообщить патчерам об этом префиксе, установив 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

Вложенные декораторы патча

Если вы хотите выполнить несколько патчей, то вы можете просто наложить декораторы друг на друга.

Вы можете наложить несколько декораторов патчей, используя этот шаблон:

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

Обратите внимание, что декораторы применяются сверху вниз. Это стандартный способ применения декораторов в Python. Порядок созданных моков, передаваемых в вашу тестовую функцию, соответствует этому порядку.

Где производить патч

patch() работает, временно изменяя объект, на который указывает имя, на другой. Может быть много имён, указывающих на любой отдельный объект, поэтому для работы патча необходимо убедиться, что вы патчите имя, используемое тестируемой системой.

Основной принцип заключается в том, что вы патчите то место, где ищется объект, а это не обязательно то же самое место, где он определяется. Несколько примеров помогут прояснить это.

Представьте, что у нас есть проект, который мы хотим протестировать со следующей структурой:

a.py
    -> Defines SomeClass

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

Теперь мы хотим протестировать some_function, но хотим смоделировать SomeClass с помощью patch(). Проблема в том, что когда мы импортируем модуль b, что нам придётся сделать, он импортирует SomeClass из модуля a. Если мы используем patch() для моделирования a.SomeClass, то это не повлияет на наш тест; модуль b уже имеет ссылку на реальный SomeClass и кажется, что наш патч не повлиял.

Ключ — в том, чтобы заменить SomeClass там, где он используется (или где он ищется). В этом случае some_function будет на самом деле искать SomeClass в модуле b, куда мы его импортировали. Патч должен выглядеть так:

@patch('b.SomeClass')

Однако, рассмотрите альтернативный сценарий, где вместо from a import SomeClass модуль b делает import a и some_function использует a.SomeClass. Оба эти способа импорта распространены. В этом случае класс, который мы хотим патчить, ищется в модуле, и поэтому нам нужно патчить a.SomeClass вместо этого:

@patch('a.SomeClass')

Патчинг дескрипторов и прокси-объектов

И patch, и patch.object корректно патчат и восстанавливают дескрипторы: методы класса, статические методы и свойства. Вы должны патчить их в классе, а не в экземпляре. Они также работают с некоторыми объектами, которые проксируют доступ к атрибутам, например, с объектом настроек django.

Моделирование магических методов

Mock поддерживает моделирование методов протокола Python, также известных как “магические методы”. Это позволяет объектам-мокам заменять контейнеры или другие объекты, реализующие протоколы Python.

Поскольку магические методы ищутся по-другому, чем обычные методы [2], эта поддержка была реализована специально. Это означает, что поддерживаются только определенные магические методы. Поддерживаемый список включает почти все из них. Если вы заметите какие-либо отсутствующие, сообщите нам, пожалуйста.

Вы моделируете магические методы, устанавливая интересующий метод в функцию или экземпляр мока. Если вы используете функцию, она должна принимать self в качестве первого аргумента [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)
[]

Один из вариантов использования этого — моделирование объектов, используемых в качестве менеджеров контекста в операторе with:

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

Вызовы магических методов не отображаются в method_calls, но они записываются в mock_calls.

Полный список поддерживаемых магических методов:

• __hash__, __sizeof__, __repr__ и __str__
• __dir__, __format__ и __subclasses__
• __round__, __floor__, __trunc__ и __ceil__
• Сравнения: __lt__, __gt__, __le__, __ge__, __eq__ и __ne__
• Методы контейнеров: __getitem__, __setitem__, __delitem__, __contains__, __len__, __iter__, __reversed__ и __missing__
• Менеджер контекста: __enter__, __exit__, __aenter__ и __aexit__
• Унарные числовые методы: __neg__, __pos__ и __invert__
• Числовые методы (включая варианты с правой частью и операциями на месте): __add__, __sub__, __mul__, __matmul__, __truediv__, __floordiv__, __mod__, __divmod__, __lshift__, __rshift__, __and__, __xor__, __or__, и __pow__
• Методы числового преобразования: __complex__, __int__, __float__ и __index__
• Методы дескриптора: __get__, __set__ и __delete__
• Сериализация: __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__ и __setstate__
• Представление пути файловой системы: __fspath__
• Асинхронные методы итерации: __aiter__ и __anext__

Следующие методы существуют, но не поддерживаются, поскольку они либо используются моком, либо не могут быть динамически установлены, или могут вызывать проблемы:

• __getattr__, __setattr__, __init__ и __new__
• __prepare__, __instancecheck__, __subclasscheck__, __del__

Магический Мок

Существует два MagicMock варианта: MagicMock и NonCallableMagicMock.

class unittest.mock.MagicMock(*args, **kw)

MagicMock — это подкласс Mock с реализациями по умолчанию для большинства магических методов. Вы можете использовать MagicMock без необходимости самостоятельно настраивать магические методы.

Параметры конструктора имеют такое же значение, как и для Mock.

Если вы используете аргументы spec или spec_set, то будут созданы только магические методы, существующие в спецификации.

class unittest.mock.NonCallableMagicMock(*args, **kw)

Невызываемый вариант MagicMock.

Параметры конструктора имеют такое же значение, как и для MagicMock, за исключением return_value и side_effect, которые не имеют смысла для невызываемого мока.

Магические методы устанавливаются с помощью объектов MagicMock, поэтому вы можете настраивать и использовать их стандартным образом:

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

По умолчанию многие методы протокола должны возвращать объекты определенного типа. Эти методы предварительно настроены с возвращаемым значением по умолчанию, чтобы их можно было использовать без каких-либо действий, если вам не интересно возвращаемое значение. Вы по-прежнему можете изменить возвращаемое значение вручную, если хотите.

Методы и их значения по умолчанию:

• __lt__: NotImplemented
• __gt__: NotImplemented
• __le__: NotImplemented
• __ge__: NotImplemented
• __int__: 1
• __contains__: False
• __len__: 0
• __iter__: iter([])
• __exit__: False
• __aexit__: False
• __complex__: 1j
• __float__: 1.0
• __bool__: True
• __index__: 1
• __hash__: хэш по умолчанию для мока
• __str__: строка по умолчанию для мока
• __sizeof__: размер по умолчанию для мока

Например:

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

Два метода сравнения, __eq__() и __ne__(), являются специальными. Они выполняют сравнение по умолчанию на основе тождества, используя атрибут side_effect, если вы не измените их возвращаемое значение.

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

Возвращаемое значение MagicMock.__iter__() может быть любым итерируемым объектом, а не обязательно итератором:

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

MagicMock имеет все поддерживаемые магические методы, настроенные, за исключением некоторых устаревших и малоиспользуемых.

Магические методы, которые поддерживаются, но не настроены по умолчанию в MagicMock:

• __subclasses__
• __dir__
• __format__
• __get__, __set__ и __delete__
• __reversed__ и __missing__
• __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__ и __setstate__
• __getformat__

sentinel

unittest.mock.sentinel

Объект sentinel предоставляет удобный способ предоставления уникальных объектов для ваших тестов.

Атрибуты создаются по мере необходимости при обращении к ним по имени. Обращение к одному и тому же атрибуту всегда возвращает один и тот же объект. Возвращаемые объекты имеют осмысленное представление, чтобы сообщения об ошибках тестов были удобочитаемыми.

Изменено в версии 3.7: Атрибуты sentinel теперь сохраняют свою идентичность при copied или pickled.

Иногда при тестировании необходимо проверить, что конкретный объект передается в качестве аргумента другому методу или возвращается. Для тестирования этого часто создаются именованные объекты-маяки. sentinel предоставляет удобный способ создания и тестирования идентичности таких объектов.

В этом примере мы подменяем method для возврата 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
>>> result
sentinel.some_object

DEFAULT

unittest.mock.DEFAULT

Объект DEFAULT — это предварительно созданный маяк (на самом деле sentinel.DEFAULT). Он может использоваться функциями side_effect для указания того, что следует использовать стандартное возвращаемое значение.

call

unittest.mock.call(*args, **kwargs)

call() — вспомогательный объект для упрощения утверждений, для сравнения с call_args, call_args_list, mock_calls и method_calls. call() также может использоваться с 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()

Для объекта вызова, представляющего несколько вызовов, call_list() возвращает список всех промежуточных вызовов, а также конечного вызова.

call_list особенно полезен для составления утверждений о «цепных вызовах». Цепной вызов — это несколько вызовов на одной строке кода. Это приводит к нескольким записям в mock_calls в имитации. Ручное создание последовательности вызовов может быть утомительным.

call_list() может создать последовательность вызовов из одного цепного вызова:

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

Объект call представляет собой кортеж (позиционные аргументы, именованные аргументы) или (имя, позиционные аргументы, именованные аргументы), в зависимости от способа его создания. При самостоятельном создании это не особенно интересно, но объекты call в атрибутах Mock.call_args, Mock.call_args_list и Mock.mock_calls можно просмотреть для извлечения содержащихся в них отдельных аргументов.

Объекты call в Mock.call_args и Mock.call_args_list представляют собой пары (позиционные аргументы, именованные аргументы), а объекты call в Mock.mock_calls, наряду с теми, которые созданы вами самостоятельно, представляют собой тройки (имя, позиционные аргументы, именованные аргументы).

Вы можете использовать их «кортежность» для извлечения отдельных аргументов для более сложного анализа и утверждений. Позиционные аргументы — это кортеж (пустой кортеж, если позиционных аргументов нет), а именованные аргументы — словарь:

>>> m = MagicMock(return_value=None)
>>> m(1, 2, 3, arg='one', arg2='two')
>>> kall = m.call_args
>>> kall.args
(1, 2, 3)
>>> kall.kwargs
{'arg': 'one', 'arg2': 'two'}
>>> kall.args is kall[0]
True
>>> kall.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
{'arg': 'two', 'arg2': 'three'}
>>> name is m.mock_calls[0][0]
True

create_autospec

unittest.mock.create_autospec(spec, spec_set=False, instance=False, **kwargs)

Создает объект-модель, используя другой объект в качестве спецификации. Атрибуты модели будут использовать соответствующие атрибуты объекта-спецификации в качестве своей спецификации.

Функции или методы, которые имитируются, будут проверять свои аргументы, чтобы убедиться, что они вызываются с правильной сигнатурой.

Если spec_set равно True, то попытка установить атрибуты, которых нет в объекте-спецификации, приведет к исключению AttributeError.

Если в качестве спецификации используется класс, то возвращаемое значение модели (экземпляр класса) будет иметь ту же спецификацию. Вы можете использовать класс в качестве спецификации для экземпляра объекта, передавая instance=True. Возвращаемая модель будет вызываемой только в том случае, если экземпляры модели вызываемы.

create_autospec() также принимает произвольные именованные аргументы, которые передаются в конструктор созданной модели.

См. Автоспецификация для примеров использования автоспецификации с create_autospec() и аргументом autospec для patch().

ANY

unittest.mock.ANY

Иногда вам может потребоваться сделать утверждения о некоторых аргументах в вызове имитации, но либо не заботиться о некоторых аргументах, либо извлечь их индивидуально из call_args и составить более сложные утверждения о них.

Чтобы проигнорировать определенные аргументы, вы можете передать объекты, которые равны всему. Вызовы assert_called_with() и assert_called_once_with() в этом случае будут успешными независимо от того, что было передано.

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

ANY также может использоваться в сравнениях со списками вызовов, например, mock_calls:

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

ANY не ограничивается сравнениями с объектами вызовов и поэтому может использоваться также в утверждениях тестов:

class TestStringMethods(unittest.TestCase):

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', ANY])

FILTER_DIR

unittest.mock.FILTER_DIR

FILTER_DIR — это переменная уровня модуля, которая управляет тем, как объекты-моки отвечают на dir(). По умолчанию значение True, которое использует фильтрацию, описанную ниже, для отображения только полезных членов. Если вам не нравится эта фильтрация или нужно отключить её для диагностических целей, установите mock.FILTER_DIR = False.

При включённой фильтрации dir(some_mock) отображает только полезные атрибуты и включает любые динамически созданные атрибуты, которые обычно не отображаются. Если мок был создан с помощью spec (или autospec, конечно), то показываются все атрибуты из оригинала, даже если они ещё не были обработаны:

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

Многие бесполезные (принадлежащие Mock, а не объекту, который имитируется) атрибуты, начинающиеся с подчеркивания и двойного подчеркивания, были отфильтрованы из результата вызова dir() для Mock. Если вам не нравится это поведение, вы можете отключить его, установив переключатель уровня модуля FILTER_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__',
 ...

В качестве альтернативы, вы можете использовать vars(my_mock) (члены экземпляра) и dir(type(my_mock)) (члены типа), чтобы обойти фильтрацию независимо от значения FILTER_DIR.

mock_open

unittest.mock.mock_open(mock=None, read_data=None)

Функция-помощник для создания мока, заменяющего использование open(). Она работает с open(), вызванным непосредственно или используемым как менеджер контекста.

Аргумент mock — это объект мока, который нужно настроить. Если None (по умолчанию), то для вас будет создан MagicMock с API, ограниченным методами или атрибутами, доступными для стандартных файловых дескрипторов.

read_data — это строка для read(), readline() и readlines() методов файлового дескриптора для возврата. Вызовы этих методов будут получать данные из read_data до тех пор, пока оно не исчерпается. Мок этих методов довольно прост: каждый раз, когда вызывается mock, read_data перематывается в начало. Если вам нужен больший контроль над данными, которые вы подаёте тестируемому коду, вам нужно будет настроить этот мок самостоятельно. Если этого недостаточно, пакеты системных файлов в памяти на PyPI могут предложить реалистичную файловую систему для тестирования.

Изменено в версии 3.4: Добавлена поддержка readline() и readlines(). Изменение мока read() для потребления read_data вместо его возвращения при каждом вызове.

Изменено в версии 3.5: read_data теперь сбрасывается при каждом вызове mock.

Изменено в версии 3.8: Добавлена __iter__() в реализацию, чтобы итерация (например, в циклах for) правильно потребляла read_data.

Использование open() в качестве менеджера контекста — отличный способ гарантировать, что ваши файловые дескрипторы правильно закрываются, и это становится всё более распространённым:

with open('/some/path', 'w') as f:
    f.write('something')

Проблема в том, что даже если вы имитируете вызов open(), именно возвращаемый объект используется как менеджер контекста (и у него вызываются __enter__() и __exit__()).

Имитация менеджеров контекстов с MagicMock достаточно распространена и достаточно сложна, что функция-помощник полезна.

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

И для чтения файлов:

>>> with patch('__main__.open', mock_open(read_data='bibble')) as m:
...     with open('foo') as h:
...         result = h.read()
...
>>> m.assert_called_once_with('foo')
>>> assert result == 'bibble'

Автоспессинг

Автоспессинг основан на существующей spec функции модуля mock. Он ограничивает API моков API исходного объекта (спецификации), но является рекурсивным (реализован лениво), так что атрибуты моков имеют тот же API, что и атрибуты спецификации. Кроме того, подменяемые функции/методы имеют такую же сигнатуру вызова, как и исходные, поэтому они генерируют исключение TypeError, если вызваны неправильно.

Прежде чем объяснить, как работает автоспессинг, давайте разберемся, зачем он нужен.

Mock — очень мощный и гибкий объект, но он имеет недостаток, характерный для подмены. Если вы переименуете некоторые части своего кода, члены и так далее, любые тесты, использующие старый API, но использующие моки вместо реальных объектов, всё равно пройдут. Это означает, что все тесты могут пройти, даже если ваш код некорректен.

Обратите внимание, что это еще одна причина, по которой вам нужны интеграционные тесты наряду с модульными. Тестирование всего в изоляции — это хорошо и замечательно, но если вы не тестируете, как ваши модули «связаны» друг с другом, остаётся много места для ошибок, которые тесты могли бы обнаружить.

unittest.mock уже предоставляет функцию для решения этой проблемы, называемую спецификацией. Если вы используете класс или экземпляр в качестве spec для мока, то вы можете получить доступ только к атрибутам мока, которые существуют в реальном классе:

>>> from urllib import request
>>> mock = Mock(spec=request.Request)
>>> mock.assret_called_with  # Intentional typo!
Traceback (most recent call last):
 ...
AttributeError: Mock object has no attribute 'assret_called_with'

Спецификация применяется только к самому моку, поэтому у нас по-прежнему есть та же проблема с любыми методами мока:

>>> mock.has_data()
<mock.Mock object at 0x...>
>>> mock.has_data.assret_called_with()  # Intentional typo!

Автоспессинг решает эту проблему. Вы можете либо передать autospec=True в patch() / patch.object(), либо использовать функцию create_autospec() для создания мока со спецификацией. Если вы используете аргумент autospec=True для patch(), то объект, который заменяется, будет использован как объект спецификации. Поскольку спецификация создаётся «лениво» (спецификация создаётся при обращении к атрибутам мока), вы можете использовать её с очень сложными или глубоко вложенными объектами (например, модулями, которые импортируют модули, которые импортируют модули), не теряя производительности.

Вот пример его использования:

>>> from urllib import request
>>> patcher = patch('__main__.request', autospec=True)
>>> mock_request = patcher.start()
>>> request is mock_request
True
>>> mock_request.Request
<MagicMock name='request.Request' spec='Request' id='...'>

Вы видите, что request.Request имеет спецификацию. request.Request принимает два аргумента в конструкторе (один из которых — self). Вот что происходит, если мы пытаемся вызвать его неправильно:

>>> req = request.Request()
Traceback (most recent call last):
 ...
TypeError: <lambda>() takes at least 2 arguments (1 given)

Спецификация также применяется к экземплярам классов (то есть к возвращаемому значению моков со спецификацией):

>>> req = request.Request('foo')
>>> req
<NonCallableMagicMock name='request.Request()' spec='Request' id='...'>

Request объекты не вызываемы, поэтому возвращаемое значение создания экземпляра нашего смоделированного request.Request — это невызываемый мок. При наличии спецификации любые опечатки в наших утверждениях сгенерируют правильную ошибку:

>>> req.add_header('spam', 'eggs')
<MagicMock name='request.Request().add_header()' id='...'>
>>> req.add_header.assret_called_with  # Intentional typo!
Traceback (most recent call last):
 ...
AttributeError: Mock object has no attribute 'assret_called_with'
>>> req.add_header.assert_called_with('spam', 'eggs')

Во многих случаях вам достаточно будет добавить autospec=True к вашим существующим вызовам patch(), чтобы защититься от ошибок из-за опечаток и изменений API.

Помимо использования autospec через patch(), есть функция create_autospec() для непосредственного создания моков с автоспецификацией:

>>> from urllib import request
>>> mock_request = create_autospec(request)
>>> mock_request.Request('foo', 'bar')
<NonCallableMagicMock name='mock.Request()' spec='Request' id='...'>

Однако это не лишено ограничений и оговорок, поэтому это не является поведением по умолчанию. Для того чтобы узнать, какие атрибуты доступны в объекте спецификации, autospec должен провести интроспекцию (получить доступ к атрибутам) спецификации. При переходе по атрибутам мока происходит соответствующий переход по исходному объекту. Если у ваших объектов со спецификацией есть свойства или описатели, которые могут вызвать выполнение кода, вы, возможно, не сможете использовать автоспецификацию. С другой стороны, гораздо лучше спроектировать ваши объекты так, чтобы интроспекция была безопасной [4].

Более серьезная проблема заключается в том, что часто атрибуты экземпляров создаются в методе __init__() и вообще не существуют в классе. autospec не может знать о динамически созданных атрибутах и ограничивает API видимыми атрибутами.

>>> class Something:
...   def __init__(self):
...     self.a = 33
...
>>> with patch('__main__.Something', autospec=True):
...   thing = Something()
...   thing.a
...
Traceback (most recent call last):
  ...
AttributeError: Mock object has no attribute 'a'

Существует несколько способов решения этой проблемы. Самый простой, но не обязательно самый удобный способ — просто установить необходимые атрибуты в моке после его создания. Просто потому, что autospec не позволяет получать доступ к атрибутам, которые не существуют в спецификации, это не мешает вам их устанавливать:

>>> with patch('__main__.Something', autospec=True):
...   thing = Something()
...   thing.a = 33
...

Существует более жёсткая версия как spec, так и autospec, которая препятствует установке несуществующих атрибутов. Это полезно, если вы хотите гарантировать, что ваш код устанавливает только действительные атрибуты, но, очевидно, это предотвращает этот конкретный сценарий:

>>> with patch('__main__.Something', autospec=True, spec_set=True):
...   thing = Something()
...   thing.a = 33
...
Traceback (most recent call last):
 ...
AttributeError: Mock object has no attribute 'a'

Наверное, лучший способ решить проблему — добавить атрибуты класса в качестве значений по умолчанию для членов экземпляров, инициализированных в __init__(). Обратите внимание, что если вы только устанавливаете значения по умолчанию в __init__(), то их предоставление через атрибуты класса (общие для экземпляров, разумеется) также быстрее. Например:

class Something:
    a = 33

Это поднимает еще одну проблему. Довольно часто в качестве значения по умолчанию для членов, которые позже будут объектами другого типа, предоставляется None. None будет бесполезен в качестве спецификации, потому что он не позволит получить доступ к каким-либо атрибутам или методам. Поскольку None никогда не будет полезен в качестве спецификации и, вероятно, указывает на член, который обычно будет какого-то другого типа, autospec не использует спецификацию для членов, установленных в None. Они просто будут обычными моками (ну, — MagicMocks):

>>> class Something:
...     member = None
...
>>> mock = create_autospec(Something)
>>> mock.member.foo.bar.baz()
<MagicMock name='mock.member.foo.bar.baz()' id='...'>

Если модификация ваших производственных классов для добавления значений по умолчанию вам не подходит, есть другие варианты. Один из них — просто использовать экземпляр в качестве спецификации вместо класса. Другой — создать подкласс производственного класса и добавить значения по умолчанию в подкласс, не затрагивая производственный класс. В обоих случаях вам нужно использовать другой объект в качестве спецификации. К счастью, patch() поддерживает это — вы просто можете передать альтернативный объект в качестве аргумента autospec:

>>> class Something:
...   def __init__(self):
...     self.a = 33
...
>>> class SomethingForTest(Something):
...   a = 33
...
>>> p = patch('__main__.Something', autospec=SomethingForTest)
>>> mock = p.start()
>>> mock.a
<NonCallableMagicMock name='Something.a' spec='int' id='...'>

Запечатывание моков

unittest.mock.seal(mock)

Запечатывание отключит автоматическое создание моков при обращении к атрибуту запечатываемого мока или любому из его атрибутов, которые уже являются моками рекурсивно.

Если экземпляр мока с именем или спецификацией присваивается атрибуту, он не будет рассматриваться в цепочке запечатывания. Это позволяет предотвратить исправление части объекта мока функцией seal.

>>> mock = Mock()
>>> mock.submock.attribute1 = 2
>>> mock.not_submock = mock.Mock(name="sample_name")
>>> seal(mock)
>>> mock.new_attribute  # This will raise AttributeError.
>>> mock.submock.attribute2  # This will raise AttributeError.
>>> mock.not_submock.attribute2  # This won't raise.

Добавлена в версии 3.7.