unittest.mock.md

1> **Источник:** https://python-all.ru/3.9/library/unittest.mock.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`unittest.mock`](https://python-all.ru/3.9/library/unittest.mock.html#module-unittest.mock) – библиотека mock-объектов89Новое в версии 3.3.1011**Исходный код:** [Lib/unittest/mock.py](https://python-all.ru/src/3.9/Lib/unittest/mock.py)1213---1415[`unittest.mock`](https://python-all.ru/3.9/library/unittest.mock.html#module-unittest.mock) – это библиотека для тестирования в Python. Она позволяет заменять части тестируемой системы mock-объектами и делать утверждения о том, как они были использованы.1617[`unittest.mock`](https://python-all.ru/3.9/library/unittest.mock.html#module-unittest.mock) предоставляет базовый класс [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), устраняя необходимость создания множества заглушек во всём наборе тестов. После выполнения действия можно делать утверждения о том, какие методы/атрибуты использовались и с какими аргументами они были вызваны. Также можно задавать возвращаемые значения и устанавливать нужные атрибуты обычным способом.1819Кроме того, mock предоставляет декоратор [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), который обрабатывает подмену атрибутов модуля и класса в рамках теста, а также [`sentinel`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.sentinel) для создания уникальных объектов. Смотрите [краткое руководство](https://python-all.ru/3.9/library/unittest.mock.html#quick-guide) для примеров использования [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) и [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch).2021Mock разработан для использования с [`unittest`](https://python-all.ru/3.9/library/unittest.html#module-unittest) и основан на шаблоне «действие -\> утверждение» вместо «запись -\> воспроизведение», используемого многими фреймворками для имитации.2223Существует обратный порт [`unittest.mock`](https://python-all.ru/3.9/library/unittest.mock.html#module-unittest.mock) для более ранних версий Python, доступный как [mock на PyPI](https://python-all.ru/3.9/library/unittest.mock.html).2425## Краткое руководство2627Объекты [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) и [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) создают все атрибуты и методы по мере обращения к ним и сохраняют сведения о том, как они использовались. Можно настраивать их, задавая возвращаемые значения или ограничивая доступные атрибуты, а затем делать утверждения о том, как они были использованы:2829```python30>>> from unittest.mock import MagicMock31>>> thing = ProductionClass()32>>> thing.method = MagicMock(return_value=3)33>>> thing.method(3, 4, 5, key='value')34335>>> thing.method.assert_called_with(3, 4, 5, key='value')36```3738`side_effect` позволяет выполнять побочные эффекты, в том числе вызывать исключение при вызове mock-объекта:3940```python41>>> mock = Mock(side_effect=KeyError('foo'))42>>> mock()43Traceback (most recent call last):44 ...45KeyError: 'foo'46```4748```python49>>> values = {'a': 1, 'b': 2, 'c': 3}50>>> def side_effect(arg):51...     return values[arg]52...53>>> mock.side_effect = side_effect54>>> mock('a'), mock('b'), mock('c')55(1, 2, 3)56>>> mock.side_effect = [5, 4, 3, 2, 1]57>>> mock(), mock(), mock()58(5, 4, 3)59```6061У Mock есть много других способов настройки и управления его поведением. Например, аргумент *spec* настраивает mock так, чтобы он брал свою спецификацию из другого объекта. Попытка обратиться к атрибутам или методам mock, которые отсутствуют в спецификации, приведёт к ошибке [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).6263Декоратор/контекстный менеджер [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) упрощает имитацию классов или объектов в тестируемом модуле. Указанный объект заменяется mock-объектом (или другим объектом) во время теста и восстанавливается после его завершения:6465```python66>>> from unittest.mock import patch67>>> @patch('module.ClassName2')68... @patch('module.ClassName1')69... def test(MockClass1, MockClass2):70...     module.ClassName1()71...     module.ClassName2()72...     assert MockClass1 is module.ClassName173...     assert MockClass2 is module.ClassName274...     assert MockClass1.called75...     assert MockClass2.called76...77>>> test()78```7980> **Примечание**81>82> При вложении декораторов patch моки передаются в декорированную функцию в том же порядке, в котором они применяются (обычный порядок применения декораторов в *Python*). Это означает снизу вверх, поэтому в примере выше mock для `module.ClassName1` передаётся первым.83>84> Для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) важно, что подменяются объекты в том пространстве имён, где они ищутся. Обычно это понятно, но для быстрого ознакомления прочтите [где делать подмену](https://python-all.ru/3.9/library/unittest.mock.html#where-to-patch).8586Помимо использования в качестве декоратора, [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) можно использовать как контекстный менеджер в операторе with:8788```python89>>> with patch.object(ProductionClass, 'method', return_value=None) as mock_method:90...     thing = ProductionClass()91...     thing.method(1, 2, 3)92...93>>> mock_method.assert_called_once_with(1, 2, 3)94```9596Также есть [`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) для установки значений в словаре только в пределах области видимости и восстановления словаря в исходное состояние после завершения теста:9798```python99>>> foo = {'key': 'value'}100>>> original = foo.copy()101>>> with patch.dict(foo, {'newkey': 'newvalue'}, clear=True):102...     assert foo == {'newkey': 'newvalue'}103...104>>> assert foo == original105```106107Mock поддерживает имитацию [магических методов](https://python-all.ru/3.9/library/unittest.mock.html#magic-methods) Python. Самый простой способ использования магических методов – это класс [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock). Он позволяет делать такие вещи, как:108109```python110>>> mock = MagicMock()111>>> mock.__str__.return_value = 'foobarbaz'112>>> str(mock)113'foobarbaz'114>>> mock.__str__.assert_called_with()115```116117Mock позволяет назначать функции (или другие экземпляры Mock) магическим методам, и они будут вызываться должным образом. Класс [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) – это просто разновидность Mock, в которой все магические методы уже предсозданы (ну, по крайней мере, все полезные).118119Далее приведён пример использования магических методов с обычным классом Mock:120121```python122>>> mock = Mock()123>>> mock.__str__ = Mock(return_value='wheeeeee')124>>> str(mock)125'wheeeeee'126```127128Чтобы объекты-заглушки в тестах имели тот же API, что и заменяемые объекты, можно воспользоваться [автоспецификацией](https://python-all.ru/3.9/library/unittest.mock.html#auto-speccing). Автоспецификацию можно выполнить через аргумент *autospec* функции patch или через функцию [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec). Автоспецификация создаёт объекты-заглушки с теми же атрибутами и методами, что и заменяемые объекты, а все функции и методы (включая конструкторы) имеют ту же сигнатуру вызова, что и настоящий объект.129130Благодаря этому заглушки будут вести себя так же, как рабочий код, если их использовать неправильно:131132```python133>>> from unittest.mock import create_autospec134>>> def function(a, b, c):135...     pass136...137>>> mock_function = create_autospec(function, return_value='fishy')138>>> mock_function(1, 2, 3)139'fishy'140>>> mock_function.assert_called_once_with(1, 2, 3)141>>> mock_function('wrong arguments')142Traceback (most recent call last):143 ...144TypeError: <lambda>() takes exactly 3 arguments (1 given)145```146147[`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) также можно применять к классам – тогда копируется сигнатура метода `__init__`, и к вызываемым объектам – копируется сигнатура метода `__call__`.148149## Класс Mock150151[`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) – это гибкий объект-заглушка, предназначенный для замены заглушек и тестовых дублёров по всему коду. Заглушки вызываемы и при обращении [1](https://python-all.ru/3.9/library/unittest.mock.html#id3) создают атрибуты как новые заглушки. Обращение к одному и тому же атрибуту всегда возвращает одну и ту же заглушку. Заглушки записывают, как вы их используете, что позволяет делать утверждения о том, что ваш код с ними сделал.152153[`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) – это подкласс [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), в котором все магические методы уже предопределены и готовы к использованию. Существуют также невызываемые варианты, полезные, когда нужно подменить объекты, которые не вызываются: [`NonCallableMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.NonCallableMock) и [`NonCallableMagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.NonCallableMagicMock).154155Декораторы [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) упрощают временную замену классов в конкретном модуле объектом [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock). По умолчанию [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) создаёт для вас [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock). Можно указать альтернативный класс для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) с помощью аргумента *new\_callable* функции [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch).156157#### `class unittest.mock.Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)`158159Создаёт новый объект [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock). [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) принимает несколько необязательных аргументов, задающих поведение объекта Mock:160161- *spec*: может быть списком строк или существующим объектом (классом или экземпляром), который служит спецификацией для объекта-заглушки. Если передать объект, список строк формируется вызовом dir у этого объекта (исключая неподдерживаемые магические атрибуты и методы). Обращение к атрибуту, отсутствующему в этом списке, вызовет исключение [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).162163  Если *spec* – объект (а не список строк), то [`__class__`](https://python-all.ru/3.9/library/stdtypes.html#instance.__class__) возвращает класс этого объекта-спецификации. Это позволяет заглушкам проходить проверки [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance).164- *spec\_set*: более строгий вариант *spec*. Если он указан, попытка *установить* или прочитать у заглушки атрибут, отсутствующий у объекта, переданного как *spec\_set*, вызовет [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).165- *side\_effect*: функция, вызываемая каждый раз при вызове Mock. См. атрибут [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect). Полезна для возбуждения исключений или динамического изменения возвращаемых значений. Функция вызывается с теми же аргументами, что и заглушка, и если она не возвращает [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT), то возвращаемое значение этой функции становится возвращаемым значением заглушки.166167  Альтернативно *side\_effect* может быть классом исключения или экземпляром. В этом случае исключение будет возбуждено при вызове заглушки.168169  Если *side\_effect* является итерируемым, то каждый вызов заглушки будет возвращать следующее значение из итерируемого.170171  *side\_effect* можно очистить, установив его равным `None`.172- *return\_value*: значение, возвращаемое при вызове заглушки. По умолчанию это новый Mock (создаётся при первом обращении). См. атрибут [`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value).173- *unsafe*: по умолчанию любой атрибут, начинающийся с *assert* или *assret*, вызывает исключение [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError). Если передать `unsafe=True`, доступ к этим атрибутам будет разрешён.174175  Новое в версии 3.5.176- *wraps*: объект, который будет обёрнут заглушкой. Если *wraps* не равен `None`, то вызов Mock передаётся обёрнутому объекту (возвращается реальный результат). Обращение к атрибуту заглушки возвращает объект Mock, который оборачивает соответствующий атрибут обёрнутого объекта (попытка обратиться к несуществующему атрибуту вызовет [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError)).177178  Если для заглушки явно задан *return\_value*, то вызовы не передаются обёрнутому объекту, а возвращается значение *return\_value*.179- *name*: если у заглушки есть имя, оно будет использоваться в repr заглушки. Это может быть полезно для отладки. Имя распространяется на дочерние заглушки.180181Заглушки также можно вызывать с произвольными именованными аргументами. Они будут использованы для установки атрибутов заглушки после её создания. Подробнее см. метод [`configure_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.configure_mock).182183#### `assert_called()`184185Утверждает, что заглушка вызывалась хотя бы один раз.186187```python188>>> mock = Mock()189>>> mock.method()190<Mock name='mock.method()' id='...'>191>>> mock.method.assert_called()192```193194Новое в версии 3.6.195196#### `assert_called_once()`197198Утверждает, что заглушка вызывалась ровно один раз.199200```python201>>> mock = Mock()202>>> mock.method()203<Mock name='mock.method()' id='...'>204>>> mock.method.assert_called_once()205>>> mock.method()206<Mock name='mock.method()' id='...'>207>>> mock.method.assert_called_once()208Traceback (most recent call last):209...210AssertionError: Expected 'method' to have been called once. Called 2 times.211```212213Новое в версии 3.6.214215#### `assert_called_with(*args, **kwargs)`216217Этот метод – удобный способ утверждать, что последний вызов был сделан определённым образом:218219```python220>>> mock = Mock()221>>> mock.method(1, 2, 3, test='wow')222<Mock name='mock.method()' id='...'>223>>> mock.method.assert_called_with(1, 2, 3, test='wow')224```225226#### `assert_called_once_with(*args, **kwargs)`227228Утверждает, что заглушка вызывалась ровно один раз, и этот вызов был с указанными аргументами.229230```python231>>> mock = Mock(return_value=None)232>>> mock('foo', bar='baz')233>>> mock.assert_called_once_with('foo', bar='baz')234>>> mock('other', bar='values')235>>> mock.assert_called_once_with('other', bar='values')236Traceback (most recent call last):237  ...238AssertionError: Expected 'mock' to be called once. Called 2 times.239```240241#### `assert_any_call(*args, **kwargs)`242243Утверждает, что заглушка вызывалась с указанными аргументами.244245Утверждение проходит, если макет *когда-либо* вызывался, в отличие от [`assert_called_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with), которые проходят только в том случае, если вызов является самым последним, а в случае [`assert_called_once_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with) он также должен быть единственным вызовом.246247```python248>>> mock = Mock(return_value=None)249>>> mock(1, 2, arg='thing')250>>> mock('some', 'thing', 'else')251>>> mock.assert_any_call(1, 2, arg='thing')252```253254#### `assert_has_calls(calls, any_order=False)`255256Утверждает, что макет был вызван с указанными вызовами. Список [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) проверяется на наличие вызовов.257258Если *any\_order* имеет значение false, то вызовы должны быть последовательными. Допускаются дополнительные вызовы до или после указанных вызовов.259260Если *any\_order* имеет значение true, то вызовы могут быть в любом порядке, но все они должны присутствовать в [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls).261262```python263>>> mock = Mock(return_value=None)264>>> mock(1)265>>> mock(2)266>>> mock(3)267>>> mock(4)268>>> calls = [call(2), call(3)]269>>> mock.assert_has_calls(calls)270>>> calls = [call(4), call(2), call(3)]271>>> mock.assert_has_calls(calls, any_order=True)272```273274#### `assert_not_called()`275276Утверждает, что макет никогда не вызывался.277278```python279>>> m = Mock()280>>> m.hello.assert_not_called()281>>> obj = m.hello()282>>> m.hello.assert_not_called()283Traceback (most recent call last):284  ...285AssertionError: Expected 'hello' to not have been called. Called 1 times.286```287288Новое в версии 3.5.289290#### `reset_mock(*, return_value=False, side_effect=False)`291292Метод reset\_mock сбрасывает все атрибуты вызовов у макета:293294```python295>>> mock = Mock(return_value=None)296>>> mock('hello')297>>> mock.called298True299>>> mock.reset_mock()300>>> mock.called301False302```303304Изменено в версии 3.6: Добавлено два аргумента, передаваемых только по ключу, в функцию reset\_mock.305306Это может быть полезно, когда нужно выполнить серию проверок, повторно используя один и тот же объект. Обратите внимание, что [`reset_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.reset_mock) *не* очищает возвращаемое значение, [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) или любые дочерние атрибуты, которые были назначены обычным присваиванием по умолчанию. Если требуется сбросить *return\_value* или [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), то передайте соответствующий параметр как `True`. Дочерние имитации и имитация возвращаемого значения (если есть) также сбрасываются.307308> **Примечание**309>310> *return\_value* и [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) – это аргументы, передаваемые только по ключу.311312#### `mock_add_spec(spec, spec_set=False)`313314Добавляет спецификацию к макету. *spec* может быть объектом или списком строк. Только атрибуты, указанные в *spec*, можно получить как атрибуты макета.315316Если *spec\_set* имеет значение true, то можно устанавливать только атрибуты, указанные в спецификации.317318#### `attach_mock(mock, attribute)`319320Прикрепляет макет как атрибут к текущему, заменяя его имя и родителя. Вызовы прикреплённого макета будут записаны в атрибуты [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) текущего макета.321322#### `configure_mock(**kwargs)`323324Устанавливает атрибуты макета через именованные аргументы.325326Атрибуты, возвращаемые значения и побочные эффекты могут быть установлены на дочерних макетах с помощью стандартной точечной нотации и распаковки словаря в вызове метода:327328```python329>>> mock = Mock()330>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}331>>> mock.configure_mock(**attrs)332>>> mock.method()3333334>>> mock.other()335Traceback (most recent call last):336  ...337KeyError338```339340То же самое можно сделать в вызове конструктора макетов:341342```python343>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}344>>> mock = Mock(some_attribute='eggs', **attrs)345>>> mock.some_attribute346'eggs'347>>> mock.method()3483349>>> mock.other()350Traceback (most recent call last):351  ...352KeyError353```354355[`configure_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.configure_mock) существует для упрощения настройки после создания макета.356357#### `__dir__()`358359Объекты [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) ограничивают результаты `dir(some_mock)` полезными результатами. Для макетов с *spec* сюда входят все разрешённые атрибуты макета.360361Смотрите [`FILTER_DIR`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.FILTER_DIR) о том, что делает эта фильтрация и как её отключить.362363#### `_get_child_mock(**kw)`364365Создаёт дочерние макеты для атрибутов и возвращаемого значения. По умолчанию дочерние макеты будут того же типа, что и родительский. Подклассы Mock могут переопределить это для настройки способа создания дочерних макетов.366367Для невызываемых макетов будет использоваться вызываемый вариант (а не пользовательский подкласс).368369#### `called`370371Логическое значение, указывающее, был ли вызван mock-объект:372373```python374>>> mock = Mock(return_value=None)375>>> mock.called376False377>>> mock()378>>> mock.called379True380```381382#### `call_count`383384Целое число, показывающее, сколько раз был вызван mock-объект:385386```python387>>> mock = Mock(return_value=None)388>>> mock.call_count3890390>>> mock()391>>> mock()392>>> mock.call_count3932394```395396#### `return_value`397398Установите это, чтобы настроить значение, возвращаемое при вызове mock:399400```python401>>> mock = Mock()402>>> mock.return_value = 'fish'403>>> mock()404'fish'405```406407Значение по умолчанию – это mock-объект, и его можно настроить обычным способом:408409```python410>>> mock = Mock()411>>> mock.return_value.attribute = sentinel.Attribute412>>> mock.return_value()413<Mock name='mock()()' id='...'>414>>> mock.return_value.assert_called_with()415```416417[`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value) также можно установить в конструкторе:418419```python420>>> mock = Mock(return_value=3)421>>> mock.return_value4223423>>> mock()4243425```426427#### `side_effect`428429Это может быть функция, вызываемая при вызове mock-объекта, итерируемый объект или исключение (класс или экземпляр), которое должно быть возбуждено.430431Если передать функцию, она будет вызвана с теми же аргументами, что и mock, и, если функция не возвращает синглтон [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT), вызов mock вернёт результат функции. Если функция возвращает [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT), то mock вернёт своё обычное значение (из [`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value)).432433Если передать итерируемый объект, он используется для получения итератора, который должен возвращать значение при каждом вызове. Это значение может быть либо экземпляром исключения для возбуждения, либо значением, возвращаемым из вызова mock (обработка [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT) идентична случаю с функцией).434435Пример mock-объекта, возбуждающего исключение (для проверки обработки исключений API):436437```python438>>> mock = Mock()439>>> mock.side_effect = Exception('Boom!')440>>> mock()441Traceback (most recent call last):442  ...443Exception: Boom!444```445446Использование [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) для возврата последовательности значений:447448```python449>>> mock = Mock()450>>> mock.side_effect = [3, 2, 1]451>>> mock(), mock(), mock()452(3, 2, 1)453```454455Использование вызываемого объекта:456457```python458>>> mock = Mock(return_value=3)459>>> def side_effect(*args, **kwargs):460...     return DEFAULT461...462>>> mock.side_effect = side_effect463>>> mock()4643465```466467[`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) можно установить в конструкторе. Вот пример, который добавляет единицу к значению, с которым вызывается mock, и возвращает результат:468469```python470>>> side_effect = lambda value: value + 1471>>> mock = Mock(side_effect=side_effect)472>>> mock(3)4734474>>> mock(-8)475-7476```477478Установка [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) в `None` очищает его:479480```python481>>> m = Mock(side_effect=KeyError, return_value=3)482>>> m()483Traceback (most recent call last):484 ...485KeyError486>>> m.side_effect = None487>>> m()4883489```490491#### `call_args`492493Это либо `None` (если фиктивный объект не вызывался), либо аргументы, с которыми фиктивный объект был вызван в последний раз. Результат представлен в виде кортежа: первый элемент (также доступен через свойство `args`) – это позиционные аргументы, с которыми был вызван фиктивный объект (или пустой кортеж), а второй элемент (также доступен через свойство `kwargs`) – это именованные аргументы (или пустой словарь).494495```python496>>> mock = Mock(return_value=None)497>>> print(mock.call_args)498None499>>> mock()500>>> mock.call_args501call()502>>> mock.call_args == ()503True504>>> mock(3, 4)505>>> mock.call_args506call(3, 4)507>>> mock.call_args == ((3, 4),)508True509>>> mock.call_args.args510(3, 4)511>>> mock.call_args.kwargs512{}513>>> mock(3, 4, 5, key='fish', next='w00t!')514>>> mock.call_args515call(3, 4, 5, key='fish', next='w00t!')516>>> mock.call_args.args517(3, 4, 5)518>>> mock.call_args.kwargs519{'key': 'fish', 'next': 'w00t!'}520```521522[`call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args), а также элементы списков [`call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list), [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) являются объектами [`call`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call). Это кортежи, поэтому их можно распаковать для получения отдельных аргументов и создания более сложных утверждений. См. [вызовы как кортежи](https://python-all.ru/3.9/library/unittest.mock.html#calls-as-tuples).523524Изменено в версии 3.8: Добавлены свойства `args` и `kwargs`.525526#### `call_args_list`527528Это список всех вызовов mock-объекта в порядке их выполнения (поэтому длина списка равна количеству вызовов). До любых вызовов это пустой список. Объект [`call`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call) можно использовать для удобного создания списков вызовов для сравнения с [`call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list).529530```python531>>> mock = Mock(return_value=None)532>>> mock()533>>> mock(3, 4)534>>> mock(key='fish', next='w00t!')535>>> mock.call_args_list536[call(), call(3, 4), call(key='fish', next='w00t!')]537>>> expected = [(), ((3, 4),), ({'key': 'fish', 'next': 'w00t!'},)]538>>> mock.call_args_list == expected539True540```541542Элементы [`call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list) являются объектами [`call`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.9/library/unittest.mock.html#calls-as-tuples).543544#### `method_calls`545546Помимо отслеживания собственных вызовов, mock-объекты также отслеживают вызовы методов и атрибутов, а также *их* методов и атрибутов:547548```python549>>> mock = Mock()550>>> mock.method()551<Mock name='mock.method()' id='...'>552>>> mock.property.method.attribute()553<Mock name='mock.property.method.attribute()' id='...'>554>>> mock.method_calls555[call.method(), call.property.method.attribute()]556```557558Элементы [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls) являются объектами [`call`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.9/library/unittest.mock.html#calls-as-tuples).559560#### `mock_calls`561562[`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) записывает *все* вызовы mock-объекта, его методов, магических методов *и* mock-объектов возвращаемых значений.563564```python565>>> mock = MagicMock()566>>> result = mock(1, 2, 3)567>>> mock.first(a=3)568<MagicMock name='mock.first()' id='...'>569>>> mock.second()570<MagicMock name='mock.second()' id='...'>571>>> int(mock)5721573>>> result(1)574<MagicMock name='mock()()' id='...'>575>>> expected = [call(1, 2, 3), call.first(a=3), call.second(),576... call.__int__(), call()(1)]577>>> mock.mock_calls == expected578True579```580581Элементы [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) являются объектами [`call`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.9/library/unittest.mock.html#calls-as-tuples).582583> **Примечание**584>585> Способ записи [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) означает, что при вложенных вызовах параметры вышестоящих вызовов не записываются и поэтому всегда будут сравниваться как равные:586>587> ```python588> >>> mock = MagicMock()589> >>> mock.top(a=3).bottom()590> <MagicMock name='mock.top().bottom()' id='...'>591> >>> mock.mock_calls592> [call.top(a=3), call.top().bottom()]593> >>> mock.mock_calls[-1] == call.top(a=-1).bottom()594> True595> ```596597#### `__class__`598599Обычно атрибут [`__class__`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.__class__) объекта возвращает его тип. Для mock-объекта с `spec`, `__class__` вместо этого возвращает класс спецификации. Это позволяет mock-объектам проходить тесты [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance) для объекта, который они заменяют или под который маскируются:600601```python602>>> mock = Mock(spec=3)603>>> isinstance(mock, int)604True605```606607[`__class__`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.__class__) может быть присвоен, что позволяет mock пройти проверку [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance) без необходимости указывать spec:608609```python610>>> mock = Mock()611>>> mock.__class__ = dict612>>> isinstance(mock, dict)613True614```615616#### `class unittest.mock.NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)`617618Невызываемая версия [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock). Параметры конструктора имеют тот же смысл, что и в [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), за исключением *return\_value* и *side\_effect*, которые не имеют смысла для невызываемого mock.619620Объекты mock, использующие класс или экземпляр в качестве `spec` или `spec_set`, способны проходить тесты [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance):621622```python623>>> mock = Mock(spec=SomeClass)624>>> isinstance(mock, SomeClass)625True626>>> mock = Mock(spec_set=SomeClass())627>>> isinstance(mock, SomeClass)628True629```630631Классы [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) поддерживают имитацию магических методов. Подробнее см. [магические методы](https://python-all.ru/3.9/library/unittest.mock.html#magic-methods).632633Классы mock и декораторы [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) принимают произвольные именованные аргументы для настройки. Для декораторов [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) именованные аргументы передаются конструктору создаваемого mock. Именованные аргументы предназначены для настройки атрибутов mock:634635```python636>>> m = MagicMock(attribute=3, other='fish')637>>> m.attribute6383639>>> m.other640'fish'641```642643Возвращаемое значение и побочный эффект дочерних mock-объектов можно установить таким же образом, используя точечную нотацию. Поскольку точечные имена нельзя использовать непосредственно в вызове, необходимо создать словарь и распаковать его с помощью `**`:644645```python646>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}647>>> mock = Mock(some_attribute='eggs', **attrs)648>>> mock.some_attribute649'eggs'650>>> mock.method()6513652>>> mock.other()653Traceback (most recent call last):654  ...655KeyError656```657658Вызываемый mock, созданный с *spec* (или *spec\_set*), будет анализировать сигнатуру объекта спецификации при сопоставлении вызовов с mock. Следовательно, он может сопоставлять аргументы фактического вызова независимо от того, переданы они позиционно или по имени:659660```python661>>> def f(a, b, c): pass662...663>>> mock = Mock(spec=f)664>>> mock(1, 2, c=3)665<Mock name='mock()' id='140161580456576'>666>>> mock.assert_called_with(1, 2, 3)667>>> mock.assert_called_with(a=1, b=2, c=3)668```669670Это относится к [`assert_called_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_with), [`assert_called_once_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with), [`assert_has_calls()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls) и [`assert_any_call()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_any_call). При [автоспецификации](https://python-all.ru/3.9/library/unittest.mock.html#auto-speccing) это также будет применяться к вызовам методов объекта mock.671672> Изменено в версии 3.4: Добавлен анализ сигнатуры для объектов mock с указанной спецификацией и автоспецификацией.673674#### `class unittest.mock.PropertyMock(*args, **kwargs)`675676Макет, предназначенный для использования в качестве свойства или другого дескриптора в классе. [`PropertyMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.PropertyMock) предоставляет методы [`__get__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__get__) и [`__set__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__set__), чтобы можно было указать возвращаемое значение при получении.677678Получение экземпляра [`PropertyMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.PropertyMock) из объекта вызывает mock без аргументов. Установка его вызывает mock с устанавливаемым значением.679680```python681>>> class Foo:682...     @property683...     def foo(self):684...         return 'something'685...     @foo.setter686...     def foo(self, value):687...         pass688...689>>> with patch('__main__.Foo.foo', new_callable=PropertyMock) as mock_foo:690...     mock_foo.return_value = 'mockity-mock'691...     this_foo = Foo()692...     print(this_foo.foo)693...     this_foo.foo = 6694...695mockity-mock696>>> mock_foo.mock_calls697[call(), call(6)]698```699700Из-за способа хранения атрибутов mock нельзя напрямую прикрепить [`PropertyMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.PropertyMock) к объекту mock. Вместо этого можно прикрепить его к объекту типа mock:701702```python703>>> m = MagicMock()704>>> p = PropertyMock(return_value=3)705>>> type(m).foo = p706>>> m.foo7073708>>> p.assert_called_once_with()709```710711#### `class unittest.mock.AsyncMock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)`712713Асинхронная версия [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock). Объект [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock) будет вести себя так, что объект будет распознаваться как асинхронная функция, а результат вызова будет ожидаемым объектом.714715```python716>>> mock = AsyncMock()717>>> asyncio.iscoroutinefunction(mock)718True719>>> inspect.isawaitable(mock())  720True721```722723Результат `mock()` – это асинхронная функция, которая будет иметь результат `side_effect` или `return_value` после ожидания:724725- если `side_effect` – это функция, асинхронная функция вернет результат этой функции,726- если `side_effect` – это исключение, асинхронная функция возбудит это исключение,727- если `side_effect` – это итерируемый объект, асинхронная функция вернет следующее значение из итерируемого объекта; однако, если последовательность результатов исчерпана, `StopAsyncIteration` возбуждается немедленно,728- если `side_effect` не определен, асинхронная функция вернет значение, определенное `return_value`; следовательно, по умолчанию асинхронная функция возвращает новый объект [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock).729730Установка *spec* для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) или [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) в асинхронную функцию приведет к тому, что после вызова будет возвращен объект корутины.731732```python733>>> async def async_func(): pass734...735>>> mock = MagicMock(async_func)736>>> mock737<MagicMock spec='function' id='...'>738>>> mock()  739<coroutine object AsyncMockMixin._mock_call at ...>740```741742Установка *spec* для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) или [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock) в класс с асинхронными и синхронными функциями автоматически определит синхронные функции и установит их как [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) (если родительский mock является [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock) или [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock)) или [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) (если родительский mock является [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock)). Все асинхронные функции будут [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock).743744```python745>>> class ExampleClass:746...     def sync_foo():747...         pass748...     async def async_foo():749...         pass750...751>>> a_mock = AsyncMock(ExampleClass)752>>> a_mock.sync_foo753<MagicMock name='mock.sync_foo' id='...'>754>>> a_mock.async_foo755<AsyncMock name='mock.async_foo' id='...'>756>>> mock = Mock(ExampleClass)757>>> mock.sync_foo758<Mock name='mock.sync_foo' id='...'>759>>> mock.async_foo760<AsyncMock name='mock.async_foo' id='...'>761```762763Новое в версии 3.8.764765#### `assert_awaited()`766767Утверждает, что mock был ожидан хотя бы один раз. Обратите внимание, что это отделено от вызова объекта, необходимо использовать ключевое слово `await`:768769```python770>>> mock = AsyncMock()771>>> async def main(coroutine_mock):772...     await coroutine_mock773...774>>> coroutine_mock = mock()775>>> mock.called776True777>>> mock.assert_awaited()778Traceback (most recent call last):779...780AssertionError: Expected mock to have been awaited.781>>> asyncio.run(main(coroutine_mock))782>>> mock.assert_awaited()783```784785#### `assert_awaited_once()`786787Утверждает, что mock был ожидан ровно один раз.788789```python790>>> mock = AsyncMock()791>>> async def main():792...     await mock()793...794>>> asyncio.run(main())795>>> mock.assert_awaited_once()796>>> asyncio.run(main())797>>> mock.method.assert_awaited_once()798Traceback (most recent call last):799...800AssertionError: Expected mock to have been awaited once. Awaited 2 times.801```802803#### `assert_awaited_with(*args, **kwargs)`804805Утверждает, что последнее ожидание было с указанными аргументами.806807```python808>>> mock = AsyncMock()809>>> async def main(*args, **kwargs):810...     await mock(*args, **kwargs)811...812>>> asyncio.run(main('foo', bar='bar'))813>>> mock.assert_awaited_with('foo', bar='bar')814>>> mock.assert_awaited_with('other')815Traceback (most recent call last):816...817AssertionError: expected call not found.818Expected: mock('other')819Actual: mock('foo', bar='bar')820```821822#### `assert_awaited_once_with(*args, **kwargs)`823824Утверждает, что мок был вызван через await ровно один раз и с указанными аргументами.825826```python827>>> mock = AsyncMock()828>>> async def main(*args, **kwargs):829...     await mock(*args, **kwargs)830...831>>> asyncio.run(main('foo', bar='bar'))832>>> mock.assert_awaited_once_with('foo', bar='bar')833>>> asyncio.run(main('foo', bar='bar'))834>>> mock.assert_awaited_once_with('foo', bar='bar')835Traceback (most recent call last):836...837AssertionError: Expected mock to have been awaited once. Awaited 2 times.838```839840#### `assert_any_await(*args, **kwargs)`841842Утверждает, что мок когда-либо был вызван через await с указанными аргументами.843844```python845>>> mock = AsyncMock()846>>> async def main(*args, **kwargs):847...     await mock(*args, **kwargs)848...849>>> asyncio.run(main('foo', bar='bar'))850>>> asyncio.run(main('hello'))851>>> mock.assert_any_await('foo', bar='bar')852>>> mock.assert_any_await('other')853Traceback (most recent call last):854...855AssertionError: mock('other') await not found856```857858#### `assert_has_awaits(calls, any_order=False)`859860Утверждает, что мок был вызван через await с указанными вызовами. Список [`await_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock.await_args_list) проверяется на наличие ожиданий.861862Если *any\_order* равно False, то ожидания должны быть последовательными. Дополнительные вызовы могут быть до или после указанных ожиданий.863864Если *any\_order* равно True, то ожидания могут быть в любом порядке, но все они должны присутствовать в [`await_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock.await_args_list).865866```python867>>> mock = AsyncMock()868>>> async def main(*args, **kwargs):869...     await mock(*args, **kwargs)870...871>>> calls = [call("foo"), call("bar")]872>>> mock.assert_has_awaits(calls)873Traceback (most recent call last):874...875AssertionError: Awaits not found.876Expected: [call('foo'), call('bar')]877Actual: []878>>> asyncio.run(main('foo'))879>>> asyncio.run(main('bar'))880>>> mock.assert_has_awaits(calls)881```882883#### `assert_not_awaited()`884885Утверждает, что мок никогда не вызывался через await.886887```python888>>> mock = AsyncMock()889>>> mock.assert_not_awaited()890```891892#### `reset_mock(*args, **kwargs)`893894См. [`Mock.reset_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.reset_mock). Также устанавливает [`await_count`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock.await_count) в 0, [`await_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock.await_args) в None и очищает [`await_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock.await_args_list).895896#### `await_count`897898Целое число, отслеживающее, сколько раз мок-объект был вызван через await.899900```python901>>> mock = AsyncMock()902>>> async def main():903...     await mock()904...905>>> asyncio.run(main())906>>> mock.await_count9071908>>> asyncio.run(main())909>>> mock.await_count9102911```912913#### `await_args`914915Это либо `None` (если мок не был ожидан), либо аргументы, с которыми мок был вызван через await в последний раз. Работает так же, как [`Mock.call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args).916917```python918>>> mock = AsyncMock()919>>> async def main(*args):920...     await mock(*args)921...922>>> mock.await_args923>>> asyncio.run(main('foo'))924>>> mock.await_args925call('foo')926>>> asyncio.run(main('bar'))927>>> mock.await_args928call('bar')929```930931#### `await_args_list`932933Это список всех ожиданий, выполненных для мок-объекта, в порядке их поступления (таким образом, длина списка равна количеству вызовов await). Если ожиданий не было, список пуст.934935```python936>>> mock = AsyncMock()937>>> async def main(*args):938...     await mock(*args)939...940>>> mock.await_args_list941[]942>>> asyncio.run(main('foo'))943>>> mock.await_args_list944[call('foo')]945>>> asyncio.run(main('bar'))946>>> mock.await_args_list947[call('foo'), call('bar')]948```949950### Вызов951952Мок-объекты являются вызываемыми. Вызов возвращает значение, установленное как атрибут [`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value). Значение по умолчанию – новый объект Mock; он создаётся при первом обращении к возвращаемому значению (явно или при вызове мока), но затем сохраняется и возвращается каждый раз.953954Вызовы объекта будут записаны в атрибуты, такие как [`call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args) и [`call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list).955956Если установлен [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), он будет вызван после того, как вызов будет записан, поэтому если `side_effect` вызывает исключение, вызов всё равно будет записан.957958Самый простой способ заставить макет вызывать исключение при вызове – сделать [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect) классом или экземпляром исключения:959960```python961>>> m = MagicMock(side_effect=IndexError)962>>> m(1, 2, 3)963Traceback (most recent call last):964  ...965IndexError966>>> m.mock_calls967[call(1, 2, 3)]968>>> m.side_effect = KeyError('Bang!')969>>> m('two', 'three', 'four')970Traceback (most recent call last):971  ...972KeyError: 'Bang!'973>>> m.mock_calls974[call(1, 2, 3), call('two', 'three', 'four')]975```976977Если `side_effect` является функцией, то вызовы макета возвращают то, что возвращает эта функция. Функция `side_effect` вызывается с теми же аргументами, что и макет. Это позволяет динамически изменять возвращаемое значение вызова в зависимости от входных данных:978979```python980>>> def side_effect(value):981...     return value + 1982...983>>> m = MagicMock(side_effect=side_effect)984>>> m(1)9852986>>> m(2)9873988>>> m.mock_calls989[call(1), call(2)]990```991992Если вы хотите, чтобы макет по-прежнему возвращал значение по умолчанию (новый макет) или любое заданное возвращаемое значение, есть два способа сделать это. Либо вернуть `mock.return_value` изнутри `side_effect`, либо вернуть [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT):993994```python995>>> m = MagicMock()996>>> def side_effect(*args, **kwargs):997...     return m.return_value998...999>>> m.side_effect = side_effect1000>>> m.return_value = 31001>>> m()100231003>>> def side_effect(*args, **kwargs):1004...     return DEFAULT1005...1006>>> m.side_effect = side_effect1007>>> m()100831009```10101011Чтобы удалить `side_effect` и вернуться к поведению по умолчанию, установите `side_effect` в `None`:10121013```python1014>>> m = MagicMock(return_value=6)1015>>> def side_effect(*args, **kwargs):1016...     return 31017...1018>>> m.side_effect = side_effect1019>>> m()102031021>>> m.side_effect = None1022>>> m()102361024```10251026`side_effect` также может быть любым итерируемым объектом. Повторные вызовы макета будут возвращать значения из итератора (пока итератор не будет исчерпан и не будет вызвано [`StopIteration`](https://python-all.ru/3.9/library/exceptions.html#StopIteration)):10271028```python1029>>> m = MagicMock(side_effect=[1, 2, 3])1030>>> m()103111032>>> m()103321034>>> m()103531036>>> m()1037Traceback (most recent call last):1038  ...1039StopIteration1040```10411042Если какие-либо элементы итератора являются исключениями, они будут вызваны вместо того, чтобы быть возвращёнными:10431044```python1045>>> iterable = (33, ValueError, 66)1046>>> m = MagicMock(side_effect=iterable)1047>>> m()1048331049>>> m()1050Traceback (most recent call last):1051 ...1052ValueError1053>>> m()1054661055```10561057### Удаление атрибутов10581059Объекты Mock создают атрибуты по запросу. Это позволяет им притворяться объектами любого типа.10601061Возможно, вы захотите, чтобы объект макета возвращал `False` при вызове [`hasattr()`](https://python-all.ru/3.9/library/functions.html#hasattr), или вызывал [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError) при получении атрибута. Это можно сделать, передав объект в качестве `spec` для макета, но это не всегда удобно.10621063Вы «блокируете» атрибуты, удаляя их. После удаления доступ к атрибуту вызовет [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).10641065```python1066>>> mock = MagicMock()1067>>> hasattr(mock, 'm')1068True1069>>> del mock.m1070>>> hasattr(mock, 'm')1071False1072>>> del mock.f1073>>> mock.f1074Traceback (most recent call last):1075    ...1076AttributeError: f1077```10781079### Имена макетов и атрибут name10801081Поскольку «name» является аргументом конструктора [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), если вы хотите, чтобы ваш объект макета имел атрибут «name», вы не можете просто передать его при создании. Есть две альтернативы. Один из вариантов – использовать [`configure_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.configure_mock):10821083```python1084>>> mock = MagicMock()1085>>> mock.configure_mock(name='my_name')1086>>> mock.name1087'my_name'1088```10891090Более простой вариант – просто установить атрибут «name» после создания макета:10911092```python1093>>> mock = MagicMock()1094>>> mock.name = "foo"1095```10961097### Прикрепление макетов в качестве атрибутов10981099Когда вы прикрепляете макет как атрибут другого макета (или как возвращаемое значение), он становится «дочерним» для этого макета. Вызовы дочернего макета записываются в атрибуты [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) родительского. Это полезно для настройки дочерних макетов и последующего их прикрепления к родительскому, или для прикрепления макетов к родительскому, который записывает все вызовы дочерних и позволяет делать утверждения о порядке вызовов между макетами:11001101```python1102>>> parent = MagicMock()1103>>> child1 = MagicMock(return_value=None)1104>>> child2 = MagicMock(return_value=None)1105>>> parent.child1 = child11106>>> parent.child2 = child21107>>> child1(1)1108>>> child2(2)1109>>> parent.mock_calls1110[call.child1(1), call.child2(2)]1111```11121113Исключение составляет случай, когда у макета есть имя. Это позволяет предотвратить «родительскую связь», если по какой-то причине вы не хотите, чтобы это происходило.11141115```python1116>>> mock = MagicMock()1117>>> not_a_child = MagicMock(name='not-a-child')1118>>> mock.attribute = not_a_child1119>>> mock.attribute()1120<MagicMock name='not-a-child()' id='...'>1121>>> mock.mock_calls1122[]1123```11241125Макеты, созданные для вас с помощью [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), автоматически получают имена. Чтобы прикрепить макеты с именами к родительскому, используйте метод [`attach_mock()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.attach_mock) :11261127```python1128>>> thing1 = object()1129>>> thing2 = object()1130>>> parent = MagicMock()1131>>> with patch('__main__.thing1', return_value=None) as child1:1132...     with patch('__main__.thing2', return_value=None) as child2:1133...         parent.attach_mock(child1, 'child1')1134...         parent.attach_mock(child2, 'child2')1135...         child1('one')1136...         child2('two')1137...1138>>> parent.mock_calls1139[call.child1('one'), call.child2('two')]1140```11411142**[1](https://python-all.ru/3.9/library/unittest.mock.html#id1)**11431144Единственное исключение – это магические методы и атрибуты (те, которые имеют двойные подчёркивания в начале и конце). Mock не создаёт их, а вместо этого вызывает [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError). Это связано с тем, что интерпретатор часто неявно запрашивает эти методы и *очень* путается, получая новый объект Mock, когда ожидает магический метод. Если вам нужна поддержка магических методов, обратитесь к [магическим методам](https://python-all.ru/3.9/library/unittest.mock.html#magic-methods).11451146## Патчеры11471148Декораторы patch используются для патчинга объектов только в пределах области видимости функции, которую они декорируют. Они автоматически обрабатывают отмену патчинга, даже если возникают исключения. Все эти функции также могут использоваться в операторах with или в качестве декораторов классов.11491150### patch11511152> **Примечание**1153>1154> Ключ в том, чтобы выполнять патчинг в правильном пространстве имён. Смотрите раздел [где патчить](https://python-all.ru/3.9/library/unittest.mock.html#id6).11551156#### `unittest.mock.patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`11571158[`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) работает как декоратор функции, декоратор класса или контекстный менеджер. Внутри тела функции или оператора with *target* заменяется объектом *new*. Когда функция/оператор with завершается, патчинг отменяется.11591160Если *new* опущен, то цель заменяется на [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock), если патчируемый объект является асинхронной функцией, или на [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) в противном случае. Если [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) используется как декоратор и *new* опущен, созданный макет передаётся в качестве дополнительного аргумента декорируемой функции. Если [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) используется как контекстный менеджер, созданный макет возвращается контекстным менеджером.11611162*target* должен быть строкой в формате `'package.module.ClassName'`. *target* импортируется, и указанный объект заменяется на объект *new*, поэтому *target* должен быть импортируемым из окружения, в котором вы вызываете [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch). Цель импортируется при выполнении декорированной функции, а не во время декорирования.11631164Ключевые аргументы *spec* и *spec\_set* передаются в [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock), если patch создаёт его для вас.11651166Кроме того, вы можете передать `spec=True` или `spec_set=True`, что заставляет patch передать объект, который имитируется, в качестве объекта spec/spec\_set.11671168*new\_callable* позволяет указать другой класс или вызываемый объект, который будет вызван для создания объекта *new*. По умолчанию [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock) используется для асинхронных функций, а [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) – для остальных.11691170Более мощная форма *spec* – это *autospec*. Если установить `autospec=True`, то макет будет создан со спецификацией от заменяемого объекта. Все атрибуты макета также будут иметь спецификацию соответствующего атрибута заменяемого объекта. Методы и функции, которые имитируются, будут проверять свои аргументы и вызывать [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError), если они вызываются с неправильной сигнатурой. Для макетов, заменяющих класс, их возвращаемое значение («экземпляр») будет иметь ту же спецификацию, что и класс. Смотрите функцию [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) и [Autospeccing](https://python-all.ru/3.9/library/unittest.mock.html#auto-speccing).11711172Вместо `autospec=True` вы можете передать `autospec=some_object`, чтобы использовать произвольный объект в качестве спецификации вместо заменяемого.11731174По умолчанию [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) не сможет заменить атрибуты, которые не существуют. Если передать `create=True`, и атрибут не существует, patch создаст этот атрибут при вызове патченной функции и удалит его после завершения патченной функции. Это полезно для написания тестов на атрибуты, которые ваш production-код создаёт во время выполнения. По умолчанию эта возможность отключена, так как может быть опасной. Включив её, можно писать успешные тесты для API, которых на самом деле не существует!11751176> **Примечание**1177>1178> Изменено в версии 3.5: При патчинге встроенных функций в модуле не нужно передавать `create=True` – он будет добавлен по умолчанию.11791180Patch можно использовать как `TestCase` декоратор класса. Он работает путём декорирования каждого тестового метода в классе. Это уменьшает шаблонный код, когда тестовые методы используют общий набор патчей. [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) находит тесты, ища имена методов, начинающиеся с `patch.TEST_PREFIX`. По умолчанию это `'test'`, что соответствует тому, как [`unittest`](https://python-all.ru/3.9/library/unittest.html#module-unittest) находит тесты. Альтернативный префикс можно указать, задав `patch.TEST_PREFIX`.11811182Patch можно использовать как менеджер контекста с оператором with. В этом случае патч применяется к блоку с отступом после оператора with. Если используется «as», то патченный объект будет привязан к имени после «as»; это очень полезно, когда [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) создаёт мок-объект.11831184[`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) принимает произвольные именованные аргументы. Они будут переданы в [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock), если патченный объект асинхронный, в противном случае в [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock), или в *new\_callable*, если он указан.11851186`patch.dict(...)`, `patch.multiple(...)` и `patch.object(...)` доступны для альтернативных вариантов использования.11871188[`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) в качестве декоратора функции, создающего мок и передающего его в декорируемую функцию:11891190```python1191>>> @patch('__main__.SomeClass')1192... def function(normal_argument, mock_class):1193...     print(mock_class is SomeClass)1194...1195>>> function(None)1196True1197```11981199Патч класса заменяет класс на [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) *экземпляр*. Если класс инстанцируется в тестируемом коде, то будет использован [`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value) мока.12001201Если класс инстанцируется несколько раз, можно использовать [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), чтобы каждый раз возвращать новый мок. В качестве альтернативы можно установить *return\_value* во что угодно.12021203Чтобы настроить возвращаемые значения для методов *экземпляров* патченного класса, это нужно делать на `return_value`. Например:12041205```python1206>>> class Class:1207...     def method(self):1208...         pass1209...1210>>> with patch('__main__.Class') as MockClass:1211...     instance = MockClass.return_value1212...     instance.method.return_value = 'foo'1213...     assert Class() is instance1214...     assert Class().method() == 'foo'1215...1216```12171218Если используются *spec* или *spec\_set*, и [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) заменяет *класс*, то возвращаемое значение созданного мока будет иметь ту же спецификацию.12191220```python1221>>> Original = Class1222>>> patcher = patch('__main__.Class', spec=True)1223>>> MockClass = patcher.start()1224>>> instance = MockClass()1225>>> assert isinstance(instance, Original)1226>>> patcher.stop()1227```12281229Аргумент *new\_callable* полезен, когда требуется использовать альтернативный класс вместо [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) по умолчанию для создаваемого мока. Например, если нужно использовать [`NonCallableMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.NonCallableMock):12301231```python1232>>> thing = object()1233>>> with patch('__main__.thing', new_callable=NonCallableMock) as mock_thing:1234...     assert thing is mock_thing1235...     thing()1236...1237Traceback (most recent call last):1238  ...1239TypeError: 'NonCallableMock' object is not callable1240```12411242Ещё один вариант использования – замена объекта на экземпляр [`io.StringIO`](https://python-all.ru/3.9/library/io.html#io.StringIO):12431244```python1245>>> from io import StringIO1246>>> def foo():1247...     print('Something')1248...1249>>> @patch('sys.stdout', new_callable=StringIO)1250... def test(mock_stdout):1251...     foo()1252...     assert mock_stdout.getvalue() == 'Something\n'1253...1254>>> test()1255```12561257Когда [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) создаёт мок, обычно первым делом нужно настроить мок. Часть этой настройки можно выполнить в вызове patch. Любые произвольные именованные аргументы, переданные в вызов, будут использованы для установки атрибутов созданного мока:12581259```python1260>>> patcher = patch('__main__.thing', first='one', second='two')1261>>> mock_thing = patcher.start()1262>>> mock_thing.first1263'one'1264>>> mock_thing.second1265'two'1266```12671268Помимо атрибутов созданного мока, такие атрибуты дочерних моков, как [`return_value`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.return_value) и [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), также можно настроить. Их нельзя передать напрямую как именованные аргументы, но словарь с такими ключами можно развернуть в вызов [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) с помощью `**`:12691270```python1271>>> config = {'method.return_value': 3, 'other.side_effect': KeyError}1272>>> patcher = patch('__main__.thing', **config)1273>>> mock_thing = patcher.start()1274>>> mock_thing.method()127531276>>> mock_thing.other()1277Traceback (most recent call last):1278  ...1279KeyError1280```12811282По умолчанию попытка запатчить несуществующую функцию в модуле (или метод, или атрибут в классе) завершится ошибкой [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError):12831284```python1285>>> @patch('sys.non_existing_attribute', 42)1286... def test():1287...     assert sys.non_existing_attribute == 421288...1289>>> test()1290Traceback (most recent call last):1291  ...1292AttributeError: <module 'sys' (built-in)> does not have the attribute 'non_existing_attribute'1293```12941295Но добавление `create=True` в вызов [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) заставит предыдущий пример работать как ожидается:12961297```python1298>>> @patch('sys.non_existing_attribute', 42, create=True)1299... def test(mock_stdout):1300...     assert sys.non_existing_attribute == 421301...1302>>> test()1303```13041305Изменено в версии 3.8: [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) теперь возвращает [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock), если цель является асинхронной функцией.13061307### patch.object13081309#### `patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`13101311Заменяет именованный член (*атрибут*) объекта (*цель*) на мок-объект.13121313[`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) можно использовать как декоратор, декоратор класса или менеджер контекста. Аргументы *new*, *spec*, *create*, *spec\_set*, *autospec* и *new\_callable* имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch). Как и [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), [`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) принимает произвольные именованные аргументы для настройки создаваемого мок-объекта.13141315При использовании в качестве декоратора класса [`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) учитывает `patch.TEST_PREFIX` для выбора методов, которые нужно обернуть.13161317[`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) можно вызывать с тремя или двумя аргументами. Форма с тремя аргументами принимает объект для патча, имя атрибута и объект, которым нужно заменить атрибут.13181319При вызове с двумя аргументами заменяющий объект опускается, и мок создаётся и передаётся как дополнительный аргумент в декорируемую функцию:13201321```python1322>>> @patch.object(SomeClass, 'class_method')1323... def test(mock_method):1324...     SomeClass.class_method(3)1325...     mock_method.assert_called_with(3)1326...1327>>> test()1328```13291330*spec*, *create* и остальные аргументы [`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch).13311332### patch.dict13331334#### `patch.dict(in_dict, values=(), clear=False, **kwargs)`13351336Исправляет словарь или подобный словарю объект и восстанавливает его исходное состояние после завершения теста.13371338*in\_dict* может быть словарём или контейнером, подобным отображению. Если это отображение, оно должно как минимум поддерживать получение, установку и удаление элементов, а также итерацию по ключам.13391340*in\_dict* также может быть строкой, задающей имя словаря, который затем будет получен через импорт.13411342*values* может быть словарём значений для установки в словаре. *values* также может быть итерируемым объектом пар `(key, value)`.13431344Если *clear* равен true, то словарь будет очищен перед установкой новых значений.13451346[`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) также можно вызывать с произвольными именованными аргументами для установки значений в словаре.13471348Изменено в версии 3.8: [`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) теперь возвращает пропатченный словарь при использовании в качестве менеджера контекста.13491350[`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) может использоваться как менеджер контекста, декоратор или декоратор класса:13511352```python1353>>> foo = {}1354>>> @patch.dict(foo, {'newkey': 'newvalue'})1355... def test():1356...     assert foo == {'newkey': 'newvalue'}1357>>> test()1358>>> assert foo == {}1359```13601361При использовании в качестве декоратора класса [`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) учитывает `patch.TEST_PREFIX` (по умолчанию `'test'`) для выбора методов, которые нужно обернуть:13621363```python1364>>> import os1365>>> import unittest1366>>> from unittest.mock import patch1367>>> @patch.dict('os.environ', {'newkey': 'newvalue'})1368... class TestSample(unittest.TestCase):1369...     def test_sample(self):1370...         self.assertEqual(os.environ['newkey'], 'newvalue')1371```13721373Если требуется использовать другой префикс для тестов, можно указать его патчерам, задав `patch.TEST_PREFIX`. Подробнее о том, как изменить значение, см. в [TEST\_PREFIX](https://python-all.ru/3.9/library/unittest.mock.html#test-prefix).13741375[`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) позволяет добавлять элементы в словарь или просто даёт тесту изменить словарь, гарантируя, что после завершения теста словарь будет восстановлен.13761377```python1378>>> foo = {}1379>>> with patch.dict(foo, {'newkey': 'newvalue'}) as patched_foo:1380...     assert foo == {'newkey': 'newvalue'}1381...     assert patched_foo == {'newkey': 'newvalue'}1382...     # Вы можете добавлять, обновлять или удалять ключи foo (или patched_foo – это тот же словарь).1383...     patched_foo['spam'] = 'eggs'1384...1385>>> assert foo == {}1386>>> assert patched_foo == {}1387```13881389```python1390>>> import os1391>>> with patch.dict('os.environ', {'newkey': 'newvalue'}):1392...     print(os.environ['newkey'])1393...1394newvalue1395>>> assert 'newkey' not in os.environ1396```13971398Ключевые слова можно использовать в вызове [`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) для установки значений в словаре:13991400```python1401>>> mymodule = MagicMock()1402>>> mymodule.function.return_value = 'fish'1403>>> with patch.dict('sys.modules', mymodule=mymodule):1404...     import mymodule1405...     mymodule.function('some', 'args')1406...1407'fish'1408```14091410[`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) можно использовать с объектами, похожими на словари, но не являющимися словарями. Как минимум они должны поддерживать получение, установку и удаление элементов, а также либо итерацию, либо проверку принадлежности. Это соответствует магическим методам [`__getitem__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getitem__), [`__setitem__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__setitem__), [`__delitem__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__delitem__) и либо [`__iter__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__iter__), либо [`__contains__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__contains__).14111412```python1413>>> class Container:1414...     def __init__(self):1415...         self.values = {}1416...     def __getitem__(self, name):1417...         return self.values[name]1418...     def __setitem__(self, name, value):1419...         self.values[name] = value1420...     def __delitem__(self, name):1421...         del self.values[name]1422...     def __iter__(self):1423...         return iter(self.values)1424...1425>>> thing = Container()1426>>> thing['one'] = 11427>>> with patch.dict(thing, one=2, two=3):1428...     assert thing['one'] == 21429...     assert thing['two'] == 31430...1431>>> assert thing['one'] == 11432>>> assert list(thing) == ['one']1433```14341435### patch.multiple14361437#### `patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`14381439Выполняет несколько патчей за один вызов. Принимает объект для патча (либо сам объект, либо строку для его импорта) и именованные аргументы для патчей:14401441```python1442with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):1443    ...1444```14451446Используйте [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT) в качестве значения, если хотите, чтобы [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) создавал моки автоматически. В этом случае созданные моки передаются в декорированную функцию по ключу, а при использовании [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) в качестве менеджера контекста возвращается словарь.14471448[`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) можно использовать как декоратор, декоратор класса или менеджер контекста. Аргументы *spec*, *spec\_set*, *create*, *autospec* и *new\_callable* имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch). Эти аргументы применяются ко *всем* патчам, выполняемым с помощью [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple).14491450При использовании в качестве декоратора класса [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) учитывает `patch.TEST_PREFIX` для выбора методов, которые нужно обернуть.14511452Если требуется, чтобы [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) создавал моки автоматически, можно указать [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT) в качестве значения. При использовании [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) в качестве декоратора созданные моки передаются в декорированную функцию по ключу.14531454```python1455>>> thing = object()1456>>> other = object()14571458>>> @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)1459... def test_function(thing, other):1460...     assert isinstance(thing, MagicMock)1461...     assert isinstance(other, MagicMock)1462...1463>>> test_function()1464```14651466[`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) можно вкладывать в другие декораторы `patch`, но аргументы, передаваемые по ключу, следует указывать *после* любых стандартных аргументов, созданных [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch):14671468```python1469>>> @patch('sys.exit')1470... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)1471... def test_function(mock_exit, other, thing):1472...     assert 'other' in repr(other)1473...     assert 'thing' in repr(thing)1474...     assert 'exit' in repr(mock_exit)1475...1476>>> test_function()1477```14781479Если [`patch.multiple()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.multiple) используется как менеджер контекста, возвращаемое им значение – это словарь, где созданные моки сгруппированы по имени:14801481```python1482>>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:1483...     assert 'other' in repr(values['other'])1484...     assert 'thing' in repr(values['thing'])1485...     assert values['thing'] is thing1486...     assert values['other'] is other1487...1488```14891490### Методы patch: start и stop14911492У всех патчеров есть методы `start()` и `stop()`. Это упрощает применение патчей в методах `setUp` или в ситуациях, когда требуется выполнить несколько патчей без вложенных декораторов или операторов with.14931494Для их использования вызовите [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), [`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) или [`patch.dict()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.dict) как обычно и сохраните ссылку на возвращаемый объект `patcher`. Затем можно вызвать `start()`, чтобы применить патч, и `stop()`, чтобы его отменить.14951496Если [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) используется для создания мока, этот мок будет возвращён вызовом `patcher.start`.14971498```python1499>>> patcher = patch('package.module.ClassName')1500>>> from package import module1501>>> original = module.ClassName1502>>> new_mock = patcher.start()1503>>> assert module.ClassName is not original1504>>> assert module.ClassName is new_mock1505>>> patcher.stop()1506>>> assert module.ClassName is original1507>>> assert module.ClassName is not new_mock1508```15091510Типичный сценарий – выполнение нескольких патчей в методе `setUp` класса `TestCase`:15111512```python1513>>> class MyTest(unittest.TestCase):1514...     def setUp(self):1515...         self.patcher1 = patch('package.module.Class1')1516...         self.patcher2 = patch('package.module.Class2')1517...         self.MockClass1 = self.patcher1.start()1518...         self.MockClass2 = self.patcher2.start()1519...1520...     def tearDown(self):1521...         self.patcher1.stop()1522...         self.patcher2.stop()1523...1524...     def test_something(self):1525...         assert package.module.Class1 is self.MockClass11526...         assert package.module.Class2 is self.MockClass21527...1528>>> MyTest('test_something').run()1529```15301531> **Внимание**1532>1533> При использовании этой техники необходимо убедиться, что патч «отменён» вызовом `stop`. Это может быть сложнее, чем кажется, потому что если в методе `setUp` возникнет исключение, `tearDown` не будет вызван. [`unittest.TestCase.addCleanup()`](https://python-all.ru/3.9/library/unittest.html#unittest.TestCase.addCleanup) упрощает задачу:1534>1535> ```python1536> >>> class MyTest(unittest.TestCase):1537> ...     def setUp(self):1538> ...         patcher = patch('package.module.Class')1539> ...         self.MockClass = patcher.start()1540> ...         self.addCleanup(patcher.stop)1541> ...1542> ...     def test_something(self):1543> ...         assert package.module.Class is self.MockClass1544> ...1545> ```1546>1547> В качестве дополнительного бонуса больше не нужно хранить ссылку на объект `patcher`.15481549Также можно остановить все запущенные патчи с помощью [`patch.stopall()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.stopall).15501551#### `patch.stopall()`15521553Останавливает все активные патчи. Останавливает только те патчи, которые были запущены с помощью `start`.15541555### Патчинг встроенных функций: patch builtins15561557Можно патчить любые встроенные функции в модуле. В следующем примере патчится встроенная функция [`ord()`](https://python-all.ru/3.9/library/functions.html#ord):15581559```python1560>>> @patch('__main__.ord')1561... def test(mock_ord):1562...     mock_ord.return_value = 1011563...     print(ord('c'))1564...1565>>> test()15661011567```15681569### TEST\_PREFIX15701571Все патчеры можно использовать в качестве декораторов класса. В этом случае они оборачивают каждый тестовый метод класса. Патчеры распознают методы, начинающиеся с `'test'`, как тестовые. Это тот же принцип, по которому [`unittest.TestLoader`](https://python-all.ru/3.9/library/unittest.html#unittest.TestLoader) по умолчанию находит тестовые методы.15721573Возможно, потребуется использовать другой префикс для тестов. Уведомить патчеры о другом префиксе можно, установив `patch.TEST_PREFIX`:15741575```python1576>>> patch.TEST_PREFIX = 'foo'1577>>> value = 31578>>>1579>>> @patch('__main__.value', 'not three')1580... class Thing:1581...     def foo_one(self):1582...         print(value)1583...     def foo_two(self):1584...         print(value)1585...1586>>>1587>>> Thing().foo_one()1588not three1589>>> Thing().foo_two()1590not three1591>>> value159231593```15941595### Вложенные декораторы патча15961597Если нужно выполнить несколько замен, можно просто наложить декораторы друг на друга.15981599Можно накладывать несколько декораторов патча, используя такой шаблон:16001601```python1602>>> @patch.object(SomeClass, 'class_method')1603... @patch.object(SomeClass, 'static_method')1604... def test(mock1, mock2):1605...     assert SomeClass.static_method is mock11606...     assert SomeClass.class_method is mock21607...     SomeClass.static_method('foo')1608...     SomeClass.class_method('bar')1609...     return mock1, mock21610...1611>>> mock1, mock2 = test()1612>>> mock1.assert_called_once_with('foo')1613>>> mock2.assert_called_once_with('bar')1614```16151616Обратите внимание: декораторы применяются снизу вверх. Это стандартный порядок применения декораторов в Python. Порядок созданных заглушек, передаваемых в тестовую функцию, соответствует этому порядку.16171618### Где применять патч16191620[`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) работает, временно заменяя объект, на который указывает *имя*, другим объектом. На один объект может указывать много имён, поэтому для корректной работы патча необходимо заменить имя, используемое тестируемой системой.16211622Основной принцип: патч применяется там, где объект *ищется*, а это не обязательно то же место, где он определён. Несколько примеров помогут прояснить это.16231624Представим проект, который нужно протестировать, со следующей структурой:16251626```python1627a.py1628    -> Defines SomeClass16291630b.py1631    -> from a import SomeClass1632    -> some_function instantiates SomeClass1633```16341635Теперь мы хотим протестировать `some_function`, но подменить `SomeClass` с помощью [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch). Проблема в том, что когда мы импортируем модуль b (а нам придётся это сделать), он импортирует `SomeClass` из модуля a. Если мы используем [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) для подмены `a.SomeClass`, это не повлияет на наш тест: модуль b уже имеет ссылку на *настоящий* `SomeClass`, и может показаться, что наша подмена не сработала.16361637Ключ в том, чтобы заменить `SomeClass` там, где он используется (или где происходит поиск). В этом случае `some_function` будет искать `SomeClass` в модуле b, куда он был импортирован. Замена должна выглядеть так:16381639```python1640@patch('b.SomeClass')1641```16421643Однако рассмотрим альтернативный сценарий: вместо `from a import SomeClass` модуль b выполняет `import a`, и `some_function` использует `a.SomeClass`. Обе формы импорта распространены. В этом случае класс, который нужно заменить, ищется в модуле, поэтому заменять нужно `a.SomeClass`:16441645```python1646@patch('a.SomeClass')1647```16481649### Замена дескрипторов и прокси-объектов16501651И [patch](https://python-all.ru/3.9/library/unittest.mock.html#patch), и [patch.object](https://python-all.ru/3.9/library/unittest.mock.html#patch-object) корректно заменяют и восстанавливают дескрипторы: методы класса, статические методы и свойства. Заменять их следует на *классе*, а не на экземпляре. Они также работают с *некоторыми* объектами, проксирующими доступ к атрибутам, например, [объект настроек Django](https://python-all.ru/3.9/library/unittest.mock.html).16521653## MagicMock и поддержка магических методов16541655### Подмена магических методов16561657[`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) поддерживает имитацию методов протоколов Python, также известных как «магические методы». Это позволяет имитирующим объектам заменять контейнеры или другие объекты, реализующие протоколы Python.16581659Поскольку магические методы ищутся иначе, чем обычные методы [2](https://python-all.ru/3.9/library/unittest.mock.html#id9), эта поддержка была реализована специально. Это означает, что поддерживаются только определённые магические методы. Список поддерживаемых методов включает *почти* все. Если каких-то не хватает, пожалуйста, сообщите.16601661Магические методы подменяются установкой нужного метода в функцию или экземпляр заглушки. Если используется функция, она *должна* принимать `self` в качестве первого аргумента [3](https://python-all.ru/3.9/library/unittest.mock.html#id10).16621663```python1664>>> def __str__(self):1665...     return 'fooble'1666...1667>>> mock = Mock()1668>>> mock.__str__ = __str__1669>>> str(mock)1670'fooble'1671```16721673```python1674>>> mock = Mock()1675>>> mock.__str__ = Mock()1676>>> mock.__str__.return_value = 'fooble'1677>>> str(mock)1678'fooble'1679```16801681```python1682>>> mock = Mock()1683>>> mock.__iter__ = Mock(return_value=iter([]))1684>>> list(mock)1685[]1686```16871688Один из вариантов использования – подмена объектов, используемых как контекстные менеджеры в операторе [`with`](https://python-all.ru/3.9/reference/compound_stmts.html#with):16891690```python1691>>> mock = Mock()1692>>> mock.__enter__ = Mock(return_value='foo')1693>>> mock.__exit__ = Mock(return_value=False)1694>>> with mock as m:1695...     assert m == 'foo'1696...1697>>> mock.__enter__.assert_called_with()1698>>> mock.__exit__.assert_called_with(None, None, None)1699```17001701Вызовы магических методов не отображаются в [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls), но записываются в [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls).17021703> **Примечание**1704>1705> Если при создании заглушки использовать именованный аргумент *spec*, то попытка установить магический метод, отсутствующий в спецификации, вызовет [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).17061707Полный список поддерживаемых магических методов:17081709- `__hash__`, `__sizeof__`, `__repr__` и `__str__`1710- `__dir__`, `__format__` и `__subclasses__`1711- `__round__`, `__floor__`, `__trunc__` и `__ceil__`1712- Сравнения: `__lt__`, `__gt__`, `__le__`, `__ge__`, `__eq__` и `__ne__`1713- Методы контейнеров: `__getitem__`, `__setitem__`, `__delitem__`, `__contains__`, `__len__`, `__iter__`, `__reversed__` и `__missing__`1714- Контекстный менеджер: `__enter__`, `__exit__`, `__aenter__` и `__aexit__`1715- Унарные числовые методы: `__neg__`, `__pos__` и `__invert__`1716- Численные методы (включая варианты с правым операндом и на месте): `__add__`, `__sub__`, `__mul__`, `__matmul__`, `__div__`, `__truediv__`, `__floordiv__`, `__mod__`, `__divmod__`, `__lshift__`, `__rshift__`, `__and__`, `__xor__`, `__or__` и `__pow__`1717- Методы числового преобразования: `__complex__`, `__int__`, `__float__` и `__index__`1718- Методы дескрипторов: `__get__`, `__set__` и `__delete__`1719- Сериализация (pickling): `__reduce__`, `__reduce_ex__`, `__getinitargs__`, `__getnewargs__`, `__getstate__` и `__setstate__`1720- Представление пути файловой системы: `__fspath__`1721- Методы асинхронной итерации: `__aiter__` и `__anext__`17221723Изменено в версии 3.8: Добавлена поддержка [`os.PathLike.__fspath__()`](https://python-all.ru/3.9/library/os.html#os.PathLike.__fspath__).17241725Изменено в версии 3.8: Добавлена поддержка `__aenter__`, `__aexit__`, `__aiter__` и `__anext__`.17261727Следующие методы существуют, но *не* поддерживаются, так как либо используются в mock, либо не могут быть установлены динамически, либо могут вызывать проблемы:17281729- `__getattr__`, `__setattr__`, `__init__` и `__new__`1730- `__prepare__`, `__instancecheck__`, `__subclasscheck__`, `__del__`17311732### Магический макет17331734Существует два `MagicMock` варианта: [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) и [`NonCallableMagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.NonCallableMagicMock).17351736#### `class unittest.mock.MagicMock(*args, **kw)`17371738`MagicMock` является подклассом [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) с реализациями по умолчанию большинства магических методов. Можно использовать `MagicMock` без необходимости настраивать магические методы самостоятельно.17391740Параметры конструктора имеют тот же смысл, что и для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock).17411742Если используются аргументы *spec* или *spec\_set*, то будут созданы *только* магические методы, которые существуют в спецификации.17431744#### `class unittest.mock.NonCallableMagicMock(*args, **kw)`17451746Невызываемая версия [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock).17471748Параметры конструктора имеют тот же смысл, что и для [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock), за исключением *return\_value* и *side\_effect*, которые не имеют смысла для невызываемого mock.17491750Магические методы настраиваются с помощью объектов [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock), поэтому их можно настраивать и использовать обычным образом:17511752```python1753>>> mock = MagicMock()1754>>> mock[3] = 'fish'1755>>> mock.__setitem__.assert_called_with(3, 'fish')1756>>> mock.__getitem__.return_value = 'result'1757>>> mock[2]1758'result'1759```17601761По умолчанию многие методы протокола должны возвращать объекты определенного типа. Эти методы предварительно настроены с возвращаемым значением по умолчанию, так что их можно использовать, ничего не делая, если возвращаемое значение не интересует. Вы всё еще можете *установить* возвращаемое значение вручную, если хотите изменить значение по умолчанию.17621763Методы и их значения по умолчанию:17641765- `__lt__`: `NotImplemented`1766- `__gt__`: `NotImplemented`1767- `__le__`: `NotImplemented`1768- `__ge__`: `NotImplemented`1769- `__int__`: `1`1770- `__contains__`: `False`1771- `__len__`: `0`1772- `__iter__`: `iter([])`1773- `__exit__`: `False`1774- `__aexit__`: `False`1775- `__complex__`: `1j`1776- `__float__`: `1.0`1777- `__bool__`: `True`1778- `__index__`: `1`1779- `__hash__`: хэш по умолчанию для mock1780- `__str__`: строковое представление по умолчанию для mock1781- `__sizeof__`: размер по умолчанию для mock17821783Например:17841785```python1786>>> mock = MagicMock()1787>>> int(mock)178811789>>> len(mock)179001791>>> list(mock)1792[]1793>>> object() in mock1794False1795```17961797Два метода сравнения, [`__eq__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__eq__) и [`__ne__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__ne__), являются особенными. Они выполняют сравнение на равенство по умолчанию по идентичности, используя атрибут [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), если не изменить их возвращаемое значение на что-то другое:17981799```python1800>>> MagicMock() == 31801False1802>>> MagicMock() != 31803True1804>>> mock = MagicMock()1805>>> mock.__eq__.return_value = True1806>>> mock == 31807True1808```18091810Возвращаемое значение `MagicMock.__iter__()` может быть любым итерируемым объектом и не обязательно должно быть итератором:18111812```python1813>>> mock = MagicMock()1814>>> mock.__iter__.return_value = ['a', 'b', 'c']1815>>> list(mock)1816['a', 'b', 'c']1817>>> list(mock)1818['a', 'b', 'c']1819```18201821Если возвращаемое значение *является* итератором, то однократная итерация по нему израсходует его, и последующие итерации приведут к пустому списку:18221823```python1824>>> mock.__iter__.return_value = iter(['a', 'b', 'c'])1825>>> list(mock)1826['a', 'b', 'c']1827>>> list(mock)1828[]1829```18301831`MagicMock` имеет все поддерживаемые магические методы, настроенные, за исключением некоторых малоизвестных и устаревших. Вы всё еще можете настроить их, если захотите.18321833Магические методы, которые поддерживаются, но не настроены по умолчанию в `MagicMock`:18341835- `__subclasses__`1836- `__dir__`1837- `__format__`1838- `__get__`, `__set__` и `__delete__`1839- `__reversed__` и `__missing__`1840- `__reduce__`, `__reduce_ex__`, `__getinitargs__`, `__getnewargs__`, `__getstate__` и `__setstate__`1841- `__getformat__` и `__setformat__`18421843**[2](https://python-all.ru/3.9/library/unittest.mock.html#id7)**18441845Магические методы *должны* искаться в классе, а не в экземпляре. Разные версии Python непоследовательны в применении этого правила. Поддерживаемые методы протокола должны работать во всех поддерживаемых версиях Python.18461847**[3](https://python-all.ru/3.9/library/unittest.mock.html#id8)**18481849Функция в основном привязана к классу, но каждый экземпляр `Mock` изолирован от остальных.18501851## Вспомогательные функции18521853### sentinel18541855#### `unittest.mock.sentinel`18561857Объект `sentinel` предоставляет удобный способ создания уникальных объектов для тестов.18581859Атрибуты создаются по запросу при обращении к ним по имени. Обращение к одному и тому же атрибуту всегда возвращает один и тот же объект. Возвращаемые объекты имеют понятное строковое представление (repr), чтобы сообщения об ошибках тестов были читаемыми.18601861Изменено в версии 3.7: Атрибуты `sentinel` теперь сохраняют свою идентичность при их [`copied`](https://python-all.ru/3.9/library/copy.html#module-copy) или [`pickled`](https://python-all.ru/3.9/library/pickle.html#module-pickle).18621863Иногда при тестировании нужно проверить, что определённый объект передаётся как аргумент другому методу или возвращается. Часто для этого создают именованные sentinel-объекты. [`sentinel`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.sentinel) предоставляет удобный способ создания и проверки идентичности таких объектов.18641865В этом примере мы применяем монки-патчинг к `method`, чтобы он возвращал `sentinel.some_object`:18661867```python1868>>> real = ProductionClass()1869>>> real.method = Mock(name="method")1870>>> real.method.return_value = sentinel.some_object1871>>> result = real.method()1872>>> assert result is sentinel.some_object1873>>> result1874sentinel.some_object1875```18761877### DEFAULT18781879#### `unittest.mock.DEFAULT`18801881Объект [`DEFAULT`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.DEFAULT) – это предварительно созданный sentinel (фактически `sentinel.DEFAULT`). Он может использоваться функциями [`side_effect`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.side_effect), чтобы указать, что следует использовать обычное возвращаемое значение.18821883### call18841885#### `unittest.mock.call(*args, **kwargs)`18861887[`call()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call) – это вспомогательный объект для упрощения утверждений, для сравнения с [`call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args), [`call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list), [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) и [`method_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.method_calls). [`call()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call) также можно использовать с [`assert_has_calls()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls).18881889```python1890>>> m = MagicMock(return_value=None)1891>>> m(1, 2, a='foo', b='bar')1892>>> m()1893>>> m.call_args_list == [call(1, 2, a='foo', b='bar'), call()]1894True1895```18961897#### `call.call_list()`18981899Для объекта call, представляющего несколько вызовов, [`call_list()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call.call_list) возвращает список всех промежуточных вызовов, а также финального вызова.19001901`call_list` особенно полезен для проверки «цепочных вызовов». Цепочный вызов – это несколько вызовов в одной строке кода. В результате в [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls) макета появляется несколько записей. Ручное построение последовательности вызовов может быть утомительным.19021903[`call_list()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.call.call_list) может построить последовательность вызовов из того же цепочного вызова:19041905```python1906>>> m = MagicMock()1907>>> m(1).method(arg='foo').other('bar')(2.0)1908<MagicMock name='mock().method().other()()' id='...'>1909>>> kall = call(1).method(arg='foo').other('bar')(2.0)1910>>> kall.call_list()1911[call(1),1912 call().method(arg='foo'),1913 call().method().other('bar'),1914 call().method().other()(2.0)]1915>>> m.mock_calls == kall.call_list()1916True1917```19181919Объект `call` представляет собой либо кортеж (позиционные аргументы, именованные аргументы), либо (имя, позиционные аргументы, именованные аргументы) в зависимости от того, как он был создан. При самостоятельном создании это не особо важно, но объекты `call`, находящиеся в атрибутах [`Mock.call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args), [`Mock.call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list) и [`Mock.mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls), можно интроспектировать, чтобы получить отдельные аргументы, которые они содержат.19201921Объекты `call` в [`Mock.call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args) и [`Mock.call_args_list`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args_list) представляют собой кортежи из двух элементов (позиционные аргументы, именованные аргументы), тогда как объекты `call` в [`Mock.mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls), а также создаваемые вручную, являются кортежами из трёх элементов (имя, позиционные аргументы, именованные аргументы).19221923Вы можете использовать их «кортежность», чтобы извлекать отдельные аргументы для более сложной интроспекции и проверок. Позиционные аргументы – это кортеж (пустой кортеж, если позиционных аргументов нет), а именованные аргументы – это словарь:19241925```python1926>>> m = MagicMock(return_value=None)1927>>> m(1, 2, 3, arg='one', arg2='two')1928>>> kall = m.call_args1929>>> kall.args1930(1, 2, 3)1931>>> kall.kwargs1932{'arg': 'one', 'arg2': 'two'}1933>>> kall.args is kall[0]1934True1935>>> kall.kwargs is kall[1]1936True1937```19381939```python1940>>> m = MagicMock()1941>>> m.foo(4, 5, 6, arg='two', arg2='three')1942<MagicMock name='mock.foo()' id='...'>1943>>> kall = m.mock_calls[0]1944>>> name, args, kwargs = kall1945>>> name1946'foo'1947>>> args1948(4, 5, 6)1949>>> kwargs1950{'arg': 'two', 'arg2': 'three'}1951>>> name is m.mock_calls[0][0]1952True1953```19541955### create\_autospec19561957#### `unittest.mock.create_autospec(spec, spec_set=False, instance=False, **kwargs)`19581959Создаёт макет-объект, используя другой объект в качестве спецификации. Атрибуты макета будут использовать соответствующий атрибут объекта *spec* в качестве своей спецификации.19601961У макетируемых функций или методов будут проверяться аргументы, чтобы убедиться, что они вызываются с правильной сигнатурой.19621963Если *spec\_set* равен `True`, то попытка установить атрибуты, которых нет в объекте спецификации, вызовет исключение [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).19641965Если в качестве спецификации используется класс, то возвращаемое значение макета (экземпляр класса) будет иметь ту же спецификацию. Вы можете использовать класс в качестве спецификации для объекта-экземпляра, передав `instance=True`. Возвращаемый макет будет вызываемым, только если экземпляры макета вызываемы.19661967[`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) также принимает произвольные именованные аргументы, которые передаются конструктору создаваемого макета.19681969Смотрите [Autospeccing](https://python-all.ru/3.9/library/unittest.mock.html#auto-speccing) для примеров использования автоспецификации с [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) и аргументом *autospec* для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch).19701971Изменено в версии 3.8: [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) теперь возвращает [`AsyncMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.AsyncMock), если цель является асинхронной функцией.19721973### ANY19741975#### `unittest.mock.ANY`19761977Иногда может потребоваться сделать утверждения о *некоторых* аргументах вызова макета, но либо некоторые аргументы не важны, либо нужно извлечь их по отдельности из [`call_args`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.call_args) и сделать более сложные проверки.19781979Чтобы игнорировать определённые аргументы, можно передавать объекты, которые сравниваются равными с *чем угодно*. Вызовы [`assert_called_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with) тогда будут успешными независимо от того, что было передано.19801981```python1982>>> mock = Mock(return_value=None)1983>>> mock('foo', bar=object())1984>>> mock.assert_called_once_with('foo', bar=ANY)1985```19861987[`ANY`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.ANY) также можно использовать в сравнениях со списками вызовов, например: [`mock_calls`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.mock_calls):19881989```python1990>>> m = MagicMock(return_value=None)1991>>> m(1)1992>>> m(1, 2)1993>>> m(object())1994>>> m.mock_calls == [call(1), call(1, 2), ANY]1995True1996```19971998### FILTER\_DIR19992000#### `unittest.mock.FILTER_DIR`20012002[`FILTER_DIR`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.FILTER_DIR) – это переменная уровня модуля, которая управляет тем, как имитирующие объекты реагируют на [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) (только для Python 2.6 и новее). Значение по умолчанию – `True`, которое использует фильтрацию, описанную ниже, чтобы показывать только полезные члены. Если вам не нравится такая фильтрация, или её нужно отключить для диагностики, установите `mock.FILTER_DIR = False`.20032004При включённой фильтрации `dir(some_mock)` показывает только полезные атрибуты и будет включать любые динамически созданные атрибуты, которые обычно не отображаются. Если mock был создан с *spec* (или, конечно, *autospec*), то показываются все атрибуты оригинала, даже если к ним ещё не обращались:20052006```pycon2007>>> dir(Mock())2008['assert_any_call',2009 'assert_called',2010 'assert_called_once',2011 'assert_called_once_with',2012 'assert_called_with',2013 'assert_has_calls',2014 'assert_not_called',2015 'attach_mock',2016 ...2017>>> from urllib import request2018>>> dir(Mock(spec=request))2019['AbstractBasicAuthHandler',2020 'AbstractDigestAuthHandler',2021 'AbstractHTTPHandler',2022 'BaseHandler',2023 ...2024```20252026Многие не очень полезные атрибуты (приватные для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), а не для того, что имитируется) с префиксом из одного или двух подчёркиваний были отфильтрованы из результата вызова [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) на [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock). Если вам не нравится такое поведение, вы можете отключить его, установив переключатель уровня модуля [`FILTER_DIR`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.FILTER_DIR):20272028```pycon2029>>> from unittest import mock2030>>> mock.FILTER_DIR = False2031>>> dir(mock.Mock())2032['_NonCallableMock__get_return_value',2033 '_NonCallableMock__get_side_effect',2034 '_NonCallableMock__return_value_doc',2035 '_NonCallableMock__set_return_value',2036 '_NonCallableMock__set_side_effect',2037 '__call__',2038 '__class__',2039 ...2040```20412042В качестве альтернативы вы можете просто использовать `vars(my_mock)` (атрибуты экземпляра) и `dir(type(my_mock))` (атрибуты типа), чтобы обойти фильтрацию независимо от `mock.FILTER_DIR`.20432044### mock\_open20452046#### `unittest.mock.mock_open(mock=None, read_data=None)`20472048Вспомогательная функция для создания mock для замены использования [`open()`](https://python-all.ru/3.9/library/functions.html#open). Она работает для [`open()`](https://python-all.ru/3.9/library/functions.html#open), вызываемого напрямую или используемого как контекстный менеджер.20492050Аргумент *mock* – это настраиваемый объект mock. Если `None` (по умолчанию), то для вас будет создан [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) с API, ограниченным методами или атрибутами, доступными у стандартных файловых дескрипторов.20512052*read\_data* – это строка, которую методы `read()`, [`readline()`](https://python-all.ru/3.9/library/io.html#io.IOBase.readline) и [`readlines()`](https://python-all.ru/3.9/library/io.html#io.IOBase.readlines) файлового хендла должны возвращать. Вызовы этих методов будут брать данные из *read\_data*, пока она не исчерпается. Mock этих методов довольно примитивен: каждый раз при вызове *mock* *read\_data* перематывается к началу. Если вам нужен больший контроль над данными, которые вы передаёте тестируемому коду, вам придётся настроить этот mock самостоятельно. Если этого недостаточно, один из пакетов для файловой системы в памяти на [PyPI](https://python-all.ru/3.9/library/unittest.mock.html) может предложить реалистичную файловую систему для тестирования.20532054Изменено в версии 3.4: Добавлена поддержка [`readline()`](https://python-all.ru/3.9/library/io.html#io.IOBase.readline) и [`readlines()`](https://python-all.ru/3.9/library/io.html#io.IOBase.readlines). Mock для `read()` изменён – теперь он потребляет *read\_data*, а не возвращает её при каждом вызове.20552056Изменено в версии 3.5: Теперь *read\_data* сбрасывается при каждом вызове *mock*.20572058Изменено в версии 3.8: Добавлен [`__iter__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__iter__) в реализацию, чтобы итерация (например, в циклах for) правильно обрабатывала *read\_data*.20592060Использование [`open()`](https://python-all.ru/3.9/library/functions.html#open) как контекстного менеджера – отличный способ гарантировать, что ваши файловые хендлы будут правильно закрыты, и это становится всё более распространённым:20612062```python2063with open('/some/path', 'w') as f:2064    f.write('something')2065```20662067Проблема в том, что даже если вы замокаете вызов [`open()`](https://python-all.ru/3.9/library/functions.html#open), именно *возвращаемый объект* используется как контекстный менеджер (и у него вызываются [`__enter__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__exit__)).20682069Мокать контекстные менеджеры с помощью [`MagicMock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.MagicMock) достаточно распространено и замороченно, поэтому вспомогательная функция полезна.20702071```python2072>>> m = mock_open()2073>>> with patch('__main__.open', m):2074...     with open('foo', 'w') as h:2075...         h.write('some stuff')2076...2077>>> m.mock_calls2078[call('foo', 'w'),2079 call().__enter__(),2080 call().write('some stuff'),2081 call().__exit__(None, None, None)]2082>>> m.assert_called_once_with('foo', 'w')2083>>> handle = m()2084>>> handle.write.assert_called_once_with('some stuff')2085```20862087А для чтения файлов:20882089```python2090>>> with patch('__main__.open', mock_open(read_data='bibble')) as m:2091...     with open('foo') as h:2092...         result = h.read()2093...2094>>> m.assert_called_once_with('foo')2095>>> assert result == 'bibble'2096```20972098### Автоспецификация20992100Autospeccing основан на существующей `spec` функции mock. Он ограничивает API mock-объектов API исходного объекта (spec), но является рекурсивным (реализован лениво), поэтому атрибуты mock имеют только те же API, что и атрибуты spec. Кроме того, замоканные функции/методы имеют ту же сигнатуру вызова, что и оригинал, поэтому они вызывают [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError), если вызваны неправильно.21012102Прежде чем я объясню, как работает автоспекинг, вот почему он нужен.21032104[`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) – очень мощный и гибкий объект, но у него есть два недостатка при использовании для подмены объектов тестируемой системы. Один из них относится к API [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock), а другой – более общая проблема использования mock-объектов.21052106Сначала проблема, специфичная для [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock). У [`Mock`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock) есть два очень удобных метода assert: [`assert_called_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with).21072108```python2109>>> mock = Mock(name='Thing', return_value=None)2110>>> mock(1, 2, 3)2111>>> mock.assert_called_once_with(1, 2, 3)2112>>> mock(1, 2, 3)2113>>> mock.assert_called_once_with(1, 2, 3)2114Traceback (most recent call last):2115 ...2116AssertionError: Expected 'mock' to be called once. Called 2 times.2117```21182119Поскольку mock-объекты автоматически создают атрибуты по требованию и позволяют вызывать их с произвольными аргументами, опечатка в имени одного из этих методов проверок приводит к тому, что проверка просто исчезает:21202121```pycon2122>>> mock = Mock(name='Thing', return_value=None)2123>>> mock(1, 2, 3)2124>>> mock.assret_called_once_with(4, 5, 6)  # Преднамеренная опечатка!2125```21262127Из-за опечатки тесты могут проходить молча и неправильно.21282129The second issue is more general to mocking. If you refactor some of your code, rename members and so on, any tests for code that is still using the *old api* but uses mocks instead of the real objects will still pass. This means your tests can all pass even though your code is broken.21302131Обратите внимание, что это ещё одна причина, по которой нужны интеграционные тесты, а не только модульные. Тестировать всё изолированно – это хорошо, но если вы не тестируете, как ваши модули «соединены вместе», всё ещё остаётся много места для ошибок, которые тесты могли бы выявить.21322133`mock` уже предоставляет функцию для этого, называемую speccing. Если вы используете класс или экземпляр в качестве `spec` для mock, то вы можете получить доступ только к тем атрибутам mock, которые существуют в реальном классе:21342135```python2136>>> from urllib import request2137>>> mock = Mock(spec=request.Request)2138>>> mock.assret_called_with  # Преднамеренная опечатка!2139Traceback (most recent call last):2140 ...2141AttributeError: Mock object has no attribute 'assret_called_with'2142```21432144Spec применяется только к самому mock, поэтому у нас всё ещё есть та же проблема с любыми методами на mock:21452146```pycon2147>>> mock.has_data()2148<mock.Mock object at 0x...>2149>>> mock.has_data.assret_called_with()  # Преднамеренная опечатка!2150```21512152Auto-speccing решает эту проблему. Вы можете передать `autospec=True` в [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) / [`patch.object()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch.object) или использовать функцию [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec), чтобы создать mock с spec. Если вы используете аргумент `autospec=True` для [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), то заменяемый объект будет использоваться как объект spec. Поскольку speccing выполняется «лениво» (spec создаётся по мере доступа к атрибутам mock), вы можете использовать его с очень сложными или глубоко вложенными объектами (например, модулями, которые импортируют модули, которые импортируют модули) без большого удара по производительности.21532154Вот пример его использования:21552156```python2157>>> from urllib import request2158>>> patcher = patch('__main__.request', autospec=True)2159>>> mock_request = patcher.start()2160>>> request is mock_request2161True2162>>> mock_request.Request2163<MagicMock name='request.Request' spec='Request' id='...'>2164```21652166Вы можете видеть, что у `request.Request` есть spec. `request.Request` принимает два аргумента в конструкторе (один из них – *self*). Вот что произойдёт, если мы попробуем вызвать его неправильно:21672168```python2169>>> req = request.Request()2170Traceback (most recent call last):2171 ...2172TypeError: <lambda>() takes at least 2 arguments (1 given)2173```21742175Spec также применяется к инстанцированным классам (т.е. возвращаемому значению specced-моков):21762177```python2178>>> req = request.Request('foo')2179>>> req2180<NonCallableMagicMock name='request.Request()' spec='Request' id='...'>2181```21822183Объекты `Request` не являются вызываемыми, поэтому возвращаемое значение при создании экземпляра нашей имитации `request.Request` – это невызываемая заглушка. При наличии спецификации любые опечатки в утверждениях вызовут правильное исключение:21842185```python2186>>> req.add_header('spam', 'eggs')2187<MagicMock name='request.Request().add_header()' id='...'>2188>>> req.add_header.assret_called_with  # Преднамеренная опечатка!2189Traceback (most recent call last):2190 ...2191AttributeError: Mock object has no attribute 'assret_called_with'2192>>> req.add_header.assert_called_with('spam', 'eggs')2193```21942195Во многих случаях достаточно добавить `autospec=True` к существующим вызовам [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), и это защитит от ошибок из-за опечаток и изменений API.21962197Помимо использования *autospec* через [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch), существует [`create_autospec()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.create_autospec) для создания autospec-моков напрямую:21982199```python2200>>> from urllib import request2201>>> mock_request = create_autospec(request)2202>>> mock_request.Request('foo', 'bar')2203<NonCallableMagicMock name='mock.Request()' spec='Request' id='...'>2204```22052206Однако у этого подхода есть оговорки и ограничения, поэтому он не используется по умолчанию. Чтобы узнать, какие атрибуты доступны у объекта спецификации, autospec должен интроспектировать (получать доступ к атрибутам) спецификацию. Когда вы обращаетесь к атрибутам мока, под капотом происходит аналогичный обход оригинального объекта. Если у каких-то из ваших специфицированных объектов есть свойства или дескрипторы, которые могут запускать выполнение кода, то использовать autospec может не получиться. С другой стороны, гораздо лучше проектировать объекты так, чтобы интроспекция была безопасной [4](https://python-all.ru/3.9/library/unittest.mock.html#id12).22072208Более серьёзная проблема заключается в том, что атрибуты экземпляра часто создаются в методе [`__init__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__init__) и вообще не существуют на уровне класса. *autospec* не может знать о динамически созданных атрибутах и ограничивает API только видимыми атрибутами.22092210```python2211>>> class Something:2212...   def __init__(self):2213...     self.a = 332214...2215>>> with patch('__main__.Something', autospec=True):2216...   thing = Something()2217...   thing.a2218...2219Traceback (most recent call last):2220  ...2221AttributeError: Mock object has no attribute 'a'2222```22232224Существует несколько способов решить эту проблему. Самый простой (хотя и не обязательно наименее раздражающий) – просто установить нужные атрибуты на моке после его создания. То, что *autospec* не позволяет получать атрибуты, которых нет в спецификации, не мешает вам их устанавливать:22252226```python2227>>> with patch('__main__.Something', autospec=True):2228...   thing = Something()2229...   thing.a = 332230...2231```22322233Существует более строгая версия как *spec*, так и *autospec*, которая *не позволяет* устанавливать несуществующие атрибуты. Это полезно, если вы хотите гарантировать, что ваш код *устанавливает* только допустимые атрибуты, но, очевидно, это блокирует данный конкретный сценарий:22342235```python2236>>> with patch('__main__.Something', autospec=True, spec_set=True):2237...   thing = Something()2238...   thing.a = 332239...2240Traceback (most recent call last):2241 ...2242AttributeError: Mock object has no attribute 'a'2243```22442245Вероятно, лучший способ решения проблемы – добавить атрибуты класса в качестве значений по умолчанию для атрибутов экземпляра, инициализируемых в [`__init__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__init__). Обратите внимание, что если вы устанавливаете только атрибуты по умолчанию в [`__init__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__init__), то предоставление их через атрибуты класса (общие для экземпляров, разумеется) также быстрее. Например:22462247```python2248class Something:2249    a = 332250```22512252Это поднимает ещё одну проблему. Довольно часто в качестве значения по умолчанию для членов, которые позже станут объектами другого типа, используется `None`. `None` была бы бесполезна в качестве спецификации, потому что не позволила бы обращаться *ни к каким* атрибутам или методам. Поскольку `None` *никогда* не будет полезна как спецификация и, вероятно, указывает на член, который обычно имеет другой тип, автоспецификация не использует спецификацию для членов, установленных в `None`. Они будут просто обычными заглушками (точнее, магическими заглушками):22532254```python2255>>> class Something:2256...     member = None2257...2258>>> mock = create_autospec(Something)2259>>> mock.member.foo.bar.baz()2260<MagicMock name='mock.member.foo.bar.baz()' id='...'>2261```22622263Если изменение ваших производственных классов для добавления значений по умолчанию вам не по душе, есть и другие варианты. Один из них – просто использовать экземпляр в качестве спецификации вместо класса. Другой – создать подкласс производственного класса и добавить значения по умолчанию в подкласс, не затрагивая производственный класс. Оба варианта требуют использования альтернативного объекта в качестве спецификации. К счастью, [`patch()`](https://python-all.ru/3.9/library/unittest.mock.html#unittest.mock.patch) поддерживает это – можно просто передать альтернативный объект в качестве аргумента *autospec*:22642265```python2266>>> class Something:2267...   def __init__(self):2268...     self.a = 332269...2270>>> class SomethingForTest(Something):2271...   a = 332272...2273>>> p = patch('__main__.Something', autospec=SomethingForTest)2274>>> mock = p.start()2275>>> mock.a2276<NonCallableMagicMock name='Something.a' spec='int' id='...'>2277```22782279**[4](https://python-all.ru/3.9/library/unittest.mock.html#id11)**22802281Это относится только к классам или уже созданным объектам. Вызов имитированного класса для создания экземпляра мока *не создаёт* реальный экземпляр. Выполняются только обращения к атрибутам – наряду с вызовами [`dir()`](https://python-all.ru/3.9/library/functions.html#dir).22822283### Запечатывание моков22842285#### `unittest.mock.seal(mock)`22862287Функция seal отключает автоматическое создание моков при обращении к атрибуту запечатываемого мока или рекурсивно к любым его атрибутам, которые уже являются моками.22882289Если экземпляру мока с именем или спецификацией присваивается атрибут, он не будет учитываться в цепочке запечатывания. Это позволяет предотвратить запечатывание части мок-объекта.22902291```python2292>>> mock = Mock()2293>>> mock.submock.attribute1 = 22294>>> mock.not_submock = mock.Mock(name="sample_name")2295>>> seal(mock)2296>>> mock.new_attribute  # Это вызовет AttributeError.2297>>> mock.submock.attribute2  # Это вызовет AttributeError.2298>>> mock.not_submock.attribute2  # Это не вызовет исключения.2299```23002301Добавлено в версии 3.7.2302