unittest.mock.md

1> **Источник:** https://python-all.ru/3.7/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.7/library/unittest.mock.html#module-unittest.mock) – библиотека mock-объектов89Новое в версии 3.3.1011**Исходный код:** [Lib/unittest/mock.py](https://python-all.ru/src/3.7/Lib/unittest/mock.py)1213---1415[`unittest.mock`](https://python-all.ru/3.7/library/unittest.mock.html#module-unittest.mock) – это библиотека для тестирования в Python. Она позволяет заменять части тестируемой системы mock-объектами и делать утверждения о том, как они были использованы.1617[`unittest.mock`](https://python-all.ru/3.7/library/unittest.mock.html#module-unittest.mock) предоставляет базовый класс [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), устраняя необходимость создания множества заглушек во всём наборе тестов. После выполнения действия можно делать утверждения о том, какие методы/атрибуты использовались и с какими аргументами они были вызваны. Также можно задавать возвращаемые значения и устанавливать нужные атрибуты обычным способом.1819Кроме того, mock предоставляет декоратор [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), который обрабатывает подмену атрибутов модуля и класса в рамках теста, а также [`sentinel`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.sentinel) для создания уникальных объектов. Смотрите [краткое руководство](https://python-all.ru/3.7/library/unittest.mock.html#quick-guide) для примеров использования [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) и [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch).2021Mock очень прост в использовании и предназначен для работы с [`unittest`](https://python-all.ru/3.7/library/unittest.html#module-unittest). Mock основан на шаблоне «действие -\> утверждение» вместо «запись -\> воспроизведение», используемого многими фреймворками-заглушками.2223Существует обратный порт [`unittest.mock`](https://python-all.ru/3.7/library/unittest.mock.html#module-unittest.mock) для более ранних версий Python, доступный как [mock на PyPI](https://python-all.ru/3.7/library/unittest.mock.html).2425## Краткое руководство2627Объекты [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) и [`MagicMock`](https://python-all.ru/3.7/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.7/library/exceptions.html#AttributeError).6263Декоратор/контекстный менеджер [`patch()`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.patch) важно, что подменяются объекты в том пространстве имён, где они ищутся. Обычно это понятно, но для быстрого ознакомления прочтите [где делать подмену](https://python-all.ru/3.7/library/unittest.mock.html#where-to-patch).8586Помимо использования в качестве декоратора, [`patch()`](https://python-all.ru/3.7/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.7/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.7/library/unittest.mock.html#magic-methods) Python. Самый простой способ использования магических методов – это класс [`MagicMock`](https://python-all.ru/3.7/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.7/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.7/library/unittest.mock.html#auto-speccing). Автоспецификацию можно выполнить через аргумент *autospec* функции patch или через функцию [`create_autospec()`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.create_autospec) также можно применять к классам – тогда копируется сигнатура метода `__init__`, и к вызываемым объектам – копируется сигнатура метода `__call__`.148149## Класс Mock150151[`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) – это гибкий объект-заглушка, предназначенный для замены заглушек и тестовых дублёров по всему коду. Заглушки вызываемы и при обращении [1](https://python-all.ru/3.7/library/unittest.mock.html#id3) создают атрибуты как новые заглушки. Обращение к одному и тому же атрибуту всегда возвращает одну и ту же заглушку. Заглушки записывают, как вы их используете, что позволяет делать утверждения о том, что ваш код с ними сделал.152153[`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) – это подкласс [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), в котором все магические методы уже предопределены и готовы к использованию. Существуют также невызываемые варианты, полезные, когда нужно подменить объекты, которые не вызываются: [`NonCallableMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.NonCallableMock) и [`NonCallableMagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.NonCallableMagicMock).154155Декораторы [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) упрощают временную замену классов в конкретном модуле объектом [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock). По умолчанию [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) создаёт для вас [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock). Можно указать альтернативный класс для [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) с помощью аргумента *new\_callable* функции [`patch()`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock). [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) принимает несколько необязательных аргументов, задающих поведение объекта Mock:160161- *spec*: может быть списком строк или существующим объектом (классом или экземпляром), который служит спецификацией для объекта-заглушки. Если передать объект, список строк формируется вызовом dir у этого объекта (исключая неподдерживаемые магические атрибуты и методы). Обращение к атрибуту, отсутствующему в этом списке, вызовет исключение [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError).162163  Если *spec* – объект (а не список строк), то [`__class__`](https://python-all.ru/3.7/library/stdtypes.html#instance.__class__) возвращает класс этого объекта-спецификации. Это позволяет заглушкам проходить проверки [`isinstance()`](https://python-all.ru/3.7/library/functions.html#isinstance).164- *spec\_set*: более строгий вариант *spec*. Если он указан, попытка *установить* или прочитать у заглушки атрибут, отсутствующий у объекта, переданного как *spec\_set*, вызовет [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError).165- *side\_effect*: функция, вызываемая каждый раз при вызове Mock. См. атрибут [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect). Полезна для возбуждения исключений или динамического изменения возвращаемых значений. Функция вызывается с теми же аргументами, что и заглушка, и если она не возвращает [`DEFAULT`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock.return_value).173- *unsafe*: по умолчанию любой атрибут, начинающийся с *assert* или *assret*, вызывает исключение [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError). Если передать `unsafe=True`, доступ к этим атрибутам будет разрешён.174175  Новое в версии 3.5.176- *wraps*: объект, который будет обёрнут заглушкой. Если *wraps* не равен `None`, то вызов Mock передаётся обёрнутому объекту (возвращается реальный результат). Обращение к атрибуту заглушки возвращает объект Mock, который оборачивает соответствующий атрибут обёрнутого объекта (попытка обратиться к несуществующему атрибуту вызовет [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError)).177178  Если для заглушки явно задан *return\_value*, то вызовы не передаются обёрнутому объекту, а возвращается значение *return\_value*.179- *name*: если у заглушки есть имя, оно будет использоваться в repr заглушки. Это может быть полезно для отладки. Имя распространяется на дочерние заглушки.180181Заглушки также можно вызывать с произвольными именованными аргументами. Они будут использованы для установки атрибутов заглушки после её создания. Подробнее см. метод [`configure_mock()`](https://python-all.ru/3.7/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Утверждает, что mock был вызван ровно один раз, и этот вызов был с указанными аргументами.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.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with), которые проходят только в том случае, если вызов является самым последним, а в случае [`assert_called_once_with()`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) проверяется на наличие вызовов.257258Если *any\_order* имеет значение false, то вызовы должны быть последовательными. Допускаются дополнительные вызовы до или после указанных вызовов.259260Если *any\_order* имеет значение true, то вызовы могут быть в любом порядке, но все они должны присутствовать в [`mock_calls`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock.reset_mock) *не* очищает возвращаемое значение, [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect) или любые дочерние атрибуты, которые были назначены обычным присваиванием по умолчанию. Если требуется сбросить *return\_value* или [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), то передайте соответствующий параметр как `True`. Дочерние имитации и имитация возвращаемого значения (если есть) также сбрасываются.307308> **Примечание**309>310> *return\_value* и [`side_effect`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.7/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.7/library/unittest.mock.html#unittest.mock.Mock.configure_mock) существует для упрощения настройки после создания макета.356357#### `__dir__()`358359Объекты [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) ограничивают результаты `dir(some_mock)` полезными результатами. Для макетов с *spec* сюда входят все разрешённые атрибуты макета.360361Смотрите [`FILTER_DIR`](https://python-all.ru/3.7/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.7/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.7/library/unittest.mock.html#unittest.mock.DEFAULT), вызов mock вернёт результат функции. Если функция возвращает [`DEFAULT`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.DEFAULT), то mock вернёт своё обычное значение (из [`return_value`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.return_value)).432433Если передать итерируемый объект, он используется для получения итератора, который должен возвращать значение при каждом вызове. Это значение может быть либо экземпляром исключения для возбуждения, либо значением, возвращаемым из вызова mock (обработка [`DEFAULT`](https://python-all.ru/3.7/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.7/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.7/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.7/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` (если mock не вызывался), либо аргументы последнего вызова mock. Значение возвращается в виде кортежа: первый элемент – позиционные аргументы вызова (или пустой кортеж), второй – именованные аргументы (или пустой словарь).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(3, 4, 5, key='fish', next='w00t!')510>>> mock.call_args511call(3, 4, 5, key='fish', next='w00t!')512```513514[`call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args), а также элементы списков [`call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list), [`method_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) являются объектами [`call`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call). Это кортежи, поэтому их можно распаковать для получения отдельных аргументов и создания более сложных утверждений. См. [вызовы как кортежи](https://python-all.ru/3.7/library/unittest.mock.html#calls-as-tuples).515516#### `call_args_list`517518Это список всех вызовов mock-объекта в порядке их выполнения (поэтому длина списка равна количеству вызовов). До любых вызовов это пустой список. Объект [`call`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call) можно использовать для удобного создания списков вызовов для сравнения с [`call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list).519520```python521>>> mock = Mock(return_value=None)522>>> mock()523>>> mock(3, 4)524>>> mock(key='fish', next='w00t!')525>>> mock.call_args_list526[call(), call(3, 4), call(key='fish', next='w00t!')]527>>> expected = [(), ((3, 4),), ({'key': 'fish', 'next': 'w00t!'},)]528>>> mock.call_args_list == expected529True530```531532Элементы [`call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list) являются объектами [`call`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.7/library/unittest.mock.html#calls-as-tuples).533534#### `method_calls`535536Помимо отслеживания собственных вызовов, mock-объекты также отслеживают вызовы методов и атрибутов, а также *их* методов и атрибутов:537538```python539>>> mock = Mock()540>>> mock.method()541<Mock name='mock.method()' id='...'>542>>> mock.property.method.attribute()543<Mock name='mock.property.method.attribute()' id='...'>544>>> mock.method_calls545[call.method(), call.property.method.attribute()]546```547548Элементы [`method_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.method_calls) являются объектами [`call`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.7/library/unittest.mock.html#calls-as-tuples).549550#### `mock_calls`551552[`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) записывает *все* вызовы mock-объекта, его методов, магических методов *и* mock-объектов возвращаемых значений.553554```python555>>> mock = MagicMock()556>>> result = mock(1, 2, 3)557>>> mock.first(a=3)558<MagicMock name='mock.first()' id='...'>559>>> mock.second()560<MagicMock name='mock.second()' id='...'>561>>> int(mock)5621563>>> result(1)564<MagicMock name='mock()()' id='...'>565>>> expected = [call(1, 2, 3), call.first(a=3), call.second(),566... call.__int__(), call()(1)]567>>> mock.mock_calls == expected568True569```570571Элементы [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) являются объектами [`call`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call). Их можно распаковать как кортежи для получения отдельных аргументов. См. [вызовы как кортежи](https://python-all.ru/3.7/library/unittest.mock.html#calls-as-tuples).572573> **Примечание**574>575> Способ записи [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) означает, что при вложенных вызовах параметры вышестоящих вызовов не записываются и поэтому всегда будут сравниваться как равные:576>577> ```python578> >>> mock = MagicMock()579> >>> mock.top(a=3).bottom()580> <MagicMock name='mock.top().bottom()' id='...'>581> >>> mock.mock_calls582> [call.top(a=3), call.top().bottom()]583> >>> mock.mock_calls[-1] == call.top(a=-1).bottom()584> True585> ```586587#### `__class__`588589Обычно атрибут [`__class__`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.__class__) объекта возвращает его тип. Для mock-объекта с `spec`, `__class__` вместо этого возвращает класс спецификации. Это позволяет mock-объектам проходить тесты [`isinstance()`](https://python-all.ru/3.7/library/functions.html#isinstance) для объекта, который они заменяют или под который маскируются:590591```python592>>> mock = Mock(spec=3)593>>> isinstance(mock, int)594True595```596597[`__class__`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.__class__) может быть присвоен, что позволяет mock пройти проверку [`isinstance()`](https://python-all.ru/3.7/library/functions.html#isinstance) без необходимости указывать spec:598599```python600>>> mock = Mock()601>>> mock.__class__ = dict602>>> isinstance(mock, dict)603True604```605606#### `class unittest.mock.NonCallableMock(spec=None, wraps=None, name=None, spec_set=None, **kwargs)`607608Невызываемая версия [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock). Параметры конструктора имеют тот же смысл, что и в [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), за исключением *return\_value* и *side\_effect*, которые не имеют смысла для невызываемого mock.609610Объекты mock, использующие класс или экземпляр в качестве `spec` или `spec_set`, способны проходить тесты [`isinstance()`](https://python-all.ru/3.7/library/functions.html#isinstance):611612```python613>>> mock = Mock(spec=SomeClass)614>>> isinstance(mock, SomeClass)615True616>>> mock = Mock(spec_set=SomeClass())617>>> isinstance(mock, SomeClass)618True619```620621Классы [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) поддерживают имитацию магических методов. Подробнее см. [магические методы](https://python-all.ru/3.7/library/unittest.mock.html#magic-methods).622623Классы mock и декораторы [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) принимают произвольные именованные аргументы для настройки. Для декораторов [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) именованные аргументы передаются конструктору создаваемого mock. Именованные аргументы предназначены для настройки атрибутов mock:624625```python626>>> m = MagicMock(attribute=3, other='fish')627>>> m.attribute6283629>>> m.other630'fish'631```632633Возвращаемое значение и побочный эффект дочерних mock-объектов можно установить таким же образом, используя точечную нотацию. Поскольку точечные имена нельзя использовать непосредственно в вызове, необходимо создать словарь и распаковать его с помощью `**`:634635```python636>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}637>>> mock = Mock(some_attribute='eggs', **attrs)638>>> mock.some_attribute639'eggs'640>>> mock.method()6413642>>> mock.other()643Traceback (most recent call last):644  ...645KeyError646```647648Вызываемый mock, созданный с *spec* (или *spec\_set*), будет анализировать сигнатуру объекта спецификации при сопоставлении вызовов с mock. Следовательно, он может сопоставлять аргументы фактического вызова независимо от того, переданы они позиционно или по имени:649650```python651>>> def f(a, b, c): pass652...653>>> mock = Mock(spec=f)654>>> mock(1, 2, c=3)655<Mock name='mock()' id='140161580456576'>656>>> mock.assert_called_with(1, 2, 3)657>>> mock.assert_called_with(a=1, b=2, c=3)658```659660Это относится к [`assert_called_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_with), [`assert_called_once_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with), [`assert_has_calls()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls) и [`assert_any_call()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_any_call). При [автоспецификации](https://python-all.ru/3.7/library/unittest.mock.html#auto-speccing) это также будет применяться к вызовам методов объекта mock.661662> Изменено в версии 3.4: Добавлен анализ сигнатуры для объектов mock с указанной спецификацией и автоспецификацией.663664#### `class unittest.mock.PropertyMock(*args, **kwargs)`665666Макет, предназначенный для использования в качестве свойства или другого дескриптора в классе. [`PropertyMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.PropertyMock) предоставляет методы [`__get__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__get__) и [`__set__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__set__), чтобы можно было указать возвращаемое значение при получении.667668Получение экземпляра [`PropertyMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.PropertyMock) из объекта вызывает mock без аргументов. Установка его вызывает mock с устанавливаемым значением.669670```python671>>> class Foo:672...     @property673...     def foo(self):674...         return 'something'675...     @foo.setter676...     def foo(self, value):677...         pass678...679>>> with patch('__main__.Foo.foo', new_callable=PropertyMock) as mock_foo:680...     mock_foo.return_value = 'mockity-mock'681...     this_foo = Foo()682...     print(this_foo.foo)683...     this_foo.foo = 6684...685mockity-mock686>>> mock_foo.mock_calls687[call(), call(6)]688```689690Из-за способа хранения атрибутов mock нельзя напрямую прикрепить [`PropertyMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.PropertyMock) к объекту mock. Вместо этого можно прикрепить его к объекту типа mock:691692```python693>>> m = MagicMock()694>>> p = PropertyMock(return_value=3)695>>> type(m).foo = p696>>> m.foo6973698>>> p.assert_called_once_with()699```700701### Вызов702703Мок-объекты являются вызываемыми. Вызов возвращает значение, установленное как атрибут [`return_value`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.return_value). Значение по умолчанию – новый объект Mock; он создаётся при первом обращении к возвращаемому значению (явно или при вызове мока), но затем сохраняется и возвращается каждый раз.704705Вызовы объекта будут записаны в атрибуты, такие как [`call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args) и [`call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list).706707Если установлен [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), он будет вызван после того, как вызов будет записан, поэтому если `side_effect` вызывает исключение, вызов всё равно будет записан.708709Самый простой способ заставить макет вызывать исключение при вызове – сделать [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect) классом или экземпляром исключения:710711```python712>>> m = MagicMock(side_effect=IndexError)713>>> m(1, 2, 3)714Traceback (most recent call last):715  ...716IndexError717>>> m.mock_calls718[call(1, 2, 3)]719>>> m.side_effect = KeyError('Bang!')720>>> m('two', 'three', 'four')721Traceback (most recent call last):722  ...723KeyError: 'Bang!'724>>> m.mock_calls725[call(1, 2, 3), call('two', 'three', 'four')]726```727728Если `side_effect` является функцией, то вызовы макета возвращают то, что возвращает эта функция. Функция `side_effect` вызывается с теми же аргументами, что и макет. Это позволяет динамически изменять возвращаемое значение вызова в зависимости от входных данных:729730```python731>>> def side_effect(value):732...     return value + 1733...734>>> m = MagicMock(side_effect=side_effect)735>>> m(1)7362737>>> m(2)7383739>>> m.mock_calls740[call(1), call(2)]741```742743Если вы хотите, чтобы макет по-прежнему возвращал значение по умолчанию (новый макет) или любое заданное возвращаемое значение, есть два способа сделать это. Либо вернуть `mock.return_value` изнутри `side_effect`, либо вернуть [`DEFAULT`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.DEFAULT):744745```python746>>> m = MagicMock()747>>> def side_effect(*args, **kwargs):748...     return m.return_value749...750>>> m.side_effect = side_effect751>>> m.return_value = 3752>>> m()7533754>>> def side_effect(*args, **kwargs):755...     return DEFAULT756...757>>> m.side_effect = side_effect758>>> m()7593760```761762Чтобы удалить `side_effect` и вернуться к поведению по умолчанию, установите `side_effect` в `None`:763764```python765>>> m = MagicMock(return_value=6)766>>> def side_effect(*args, **kwargs):767...     return 3768...769>>> m.side_effect = side_effect770>>> m()7713772>>> m.side_effect = None773>>> m()7746775```776777`side_effect` также может быть любым итерируемым объектом. Повторные вызовы макета будут возвращать значения из итератора (пока итератор не будет исчерпан и не будет вызвано [`StopIteration`](https://python-all.ru/3.7/library/exceptions.html#StopIteration)):778779```python780>>> m = MagicMock(side_effect=[1, 2, 3])781>>> m()7821783>>> m()7842785>>> m()7863787>>> m()788Traceback (most recent call last):789  ...790StopIteration791```792793Если какие-либо элементы итератора являются исключениями, они будут вызваны вместо того, чтобы быть возвращёнными:794795```python796>>> iterable = (33, ValueError, 66)797>>> m = MagicMock(side_effect=iterable)798>>> m()79933800>>> m()801Traceback (most recent call last):802 ...803ValueError804>>> m()80566806```807808### Удаление атрибутов809810Объекты Mock создают атрибуты по запросу. Это позволяет им притворяться объектами любого типа.811812Возможно, вы захотите, чтобы объект макета возвращал `False` при вызове [`hasattr()`](https://python-all.ru/3.7/library/functions.html#hasattr), или вызывал [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError) при получении атрибута. Это можно сделать, передав объект в качестве `spec` для макета, но это не всегда удобно.813814Вы «блокируете» атрибуты, удаляя их. После удаления доступ к атрибуту вызовет [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError).815816```python817>>> mock = MagicMock()818>>> hasattr(mock, 'm')819True820>>> del mock.m821>>> hasattr(mock, 'm')822False823>>> del mock.f824>>> mock.f825Traceback (most recent call last):826    ...827AttributeError: f828```829830### Имена макетов и атрибут name831832Поскольку «name» является аргументом конструктора [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), если вы хотите, чтобы ваш объект макета имел атрибут «name», вы не можете просто передать его при создании. Есть две альтернативы. Один из вариантов – использовать [`configure_mock()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.configure_mock):833834```python835>>> mock = MagicMock()836>>> mock.configure_mock(name='my_name')837>>> mock.name838'my_name'839```840841Более простой вариант – просто установить атрибут «name» после создания макета:842843```python844>>> mock = MagicMock()845>>> mock.name = "foo"846```847848### Прикрепление макетов в качестве атрибутов849850Когда вы прикрепляете макет как атрибут другого макета (или как возвращаемое значение), он становится «дочерним» для этого макета. Вызовы дочернего макета записываются в атрибуты [`method_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.method_calls) и [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) родительского. Это полезно для настройки дочерних макетов и последующего их прикрепления к родительскому, или для прикрепления макетов к родительскому, который записывает все вызовы дочерних и позволяет делать утверждения о порядке вызовов между макетами:851852```python853>>> parent = MagicMock()854>>> child1 = MagicMock(return_value=None)855>>> child2 = MagicMock(return_value=None)856>>> parent.child1 = child1857>>> parent.child2 = child2858>>> child1(1)859>>> child2(2)860>>> parent.mock_calls861[call.child1(1), call.child2(2)]862```863864Исключение составляет случай, когда у макета есть имя. Это позволяет предотвратить «родительскую связь», если по какой-то причине вы не хотите, чтобы это происходило.865866```python867>>> mock = MagicMock()868>>> not_a_child = MagicMock(name='not-a-child')869>>> mock.attribute = not_a_child870>>> mock.attribute()871<MagicMock name='not-a-child()' id='...'>872>>> mock.mock_calls873[]874```875876Макеты, созданные для вас с помощью [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), автоматически получают имена. Чтобы прикрепить макеты с именами к родительскому, используйте метод [`attach_mock()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.attach_mock) :877878```python879>>> thing1 = object()880>>> thing2 = object()881>>> parent = MagicMock()882>>> with patch('__main__.thing1', return_value=None) as child1:883...     with patch('__main__.thing2', return_value=None) as child2:884...         parent.attach_mock(child1, 'child1')885...         parent.attach_mock(child2, 'child2')886...         child1('one')887...         child2('two')888...889>>> parent.mock_calls890[call.child1('one'), call.child2('two')]891```892893**[1](https://python-all.ru/3.7/library/unittest.mock.html#id1)**894895Единственное исключение – это магические методы и атрибуты (те, которые имеют двойные подчёркивания в начале и конце). Mock не создаёт их, а вместо этого вызывает [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError). Это связано с тем, что интерпретатор часто неявно запрашивает эти методы и *очень* путается, получая новый объект Mock, когда ожидает магический метод. Если вам нужна поддержка магических методов, обратитесь к [магическим методам](https://python-all.ru/3.7/library/unittest.mock.html#magic-methods).896897## Патчеры898899Декораторы patch используются для патчинга объектов только в пределах области видимости функции, которую они декорируют. Они автоматически обрабатывают отмену патчинга, даже если возникают исключения. Все эти функции также могут использоваться в операторах with или в качестве декораторов классов.900901### patch902903> **Примечание**904>905> [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) прост в использовании. Главное – выполнять подмену в нужном пространстве имён. См. раздел [где подменять](https://python-all.ru/3.7/library/unittest.mock.html#id5).906907#### `unittest.mock.patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`908909[`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) работает как декоратор функции, декоратор класса или контекстный менеджер. Внутри тела функции или оператора with *target* заменяется объектом *new*. Когда функция/оператор with завершается, патчинг отменяется.910911Если *new* опущен, то цель заменяется на [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock). Если [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) используется как декоратор, а *new* опущен, то созданный mock передаётся как дополнительный аргумент декорируемой функции. Если [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) используется как контекстный менеджер, то созданный mock возвращается контекстным менеджером.912913*target* должен быть строкой в формате `'package.module.ClassName'`. *target* импортируется, и указанный объект заменяется на объект *new*, поэтому *target* должен быть импортируемым из окружения, в котором вы вызываете [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch). Цель импортируется при выполнении декорированной функции, а не во время декорирования.914915Ключевые аргументы *spec* и *spec\_set* передаются в [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock), если patch создаёт его для вас.916917Кроме того, вы можете передать `spec=True` или `spec_set=True`, что заставляет patch передать объект, который имитируется, в качестве объекта spec/spec\_set.918919*new\_callable* позволяет указать другой класс или вызываемый объект, который будет вызван для создания объекта *new*. По умолчанию используется [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock).920921Более мощная форма *spec* – это *autospec*. Если установить `autospec=True`, то макет будет создан со спецификацией от заменяемого объекта. Все атрибуты макета также будут иметь спецификацию соответствующего атрибута заменяемого объекта. Методы и функции, которые имитируются, будут проверять свои аргументы и вызывать [`TypeError`](https://python-all.ru/3.7/library/exceptions.html#TypeError), если они вызываются с неправильной сигнатурой. Для макетов, заменяющих класс, их возвращаемое значение («экземпляр») будет иметь ту же спецификацию, что и класс. Смотрите функцию [`create_autospec()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.create_autospec) и [Autospeccing](https://python-all.ru/3.7/library/unittest.mock.html#auto-speccing).922923Вместо `autospec=True` вы можете передать `autospec=some_object`, чтобы использовать произвольный объект в качестве спецификации вместо заменяемого.924925По умолчанию [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) не сможет заменить атрибуты, которые не существуют. Если передать `create=True`, и атрибут не существует, patch создаст этот атрибут при вызове патченной функции и удалит его после завершения патченной функции. Это полезно для написания тестов на атрибуты, которые ваш production-код создаёт во время выполнения. По умолчанию эта возможность отключена, так как может быть опасной. Включив её, можно писать успешные тесты для API, которых на самом деле не существует!926927> **Примечание**928>929> Изменено в версии 3.5: При патчинге встроенных функций в модуле не нужно передавать `create=True` – он будет добавлен по умолчанию.930931Patch можно использовать как `TestCase` декоратор класса. Он работает путём декорирования каждого тестового метода в классе. Это уменьшает шаблонный код, когда тестовые методы используют общий набор патчей. [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) находит тесты, ища имена методов, начинающиеся с `patch.TEST_PREFIX`. По умолчанию это `'test'`, что соответствует тому, как [`unittest`](https://python-all.ru/3.7/library/unittest.html#module-unittest) находит тесты. Альтернативный префикс можно указать, задав `patch.TEST_PREFIX`.932933Patch можно использовать как менеджер контекста с оператором with. В этом случае патч применяется к блоку с отступом после оператора with. Если используется «as», то патченный объект будет привязан к имени после «as»; это очень полезно, когда [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) создаёт мок-объект.934935[`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) принимает произвольные именованные аргументы. Они будут переданы [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) (или *new\_callable*) при создании.936937`patch.dict(...)`, `patch.multiple(...)` и `patch.object(...)` доступны для альтернативных вариантов использования.938939[`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) в качестве декоратора функции, создающего мок и передающего его в декорируемую функцию:940941```python942>>> @patch('__main__.SomeClass')943... def function(normal_argument, mock_class):944...     print(mock_class is SomeClass)945...946>>> function(None)947True948```949950Патч класса заменяет класс на [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) *экземпляр*. Если класс инстанцируется в тестируемом коде, то будет использован [`return_value`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.return_value) мока.951952Если класс инстанцируется несколько раз, можно использовать [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), чтобы каждый раз возвращать новый мок. В качестве альтернативы можно установить *return\_value* во что угодно.953954Чтобы настроить возвращаемые значения для методов *экземпляров* патченного класса, это нужно делать на `return_value`. Например:955956```python957>>> class Class:958...     def method(self):959...         pass960...961>>> with patch('__main__.Class') as MockClass:962...     instance = MockClass.return_value963...     instance.method.return_value = 'foo'964...     assert Class() is instance965...     assert Class().method() == 'foo'966...967```968969Если используются *spec* или *spec\_set*, и [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) заменяет *класс*, то возвращаемое значение созданного мока будет иметь ту же спецификацию.970971```python972>>> Original = Class973>>> patcher = patch('__main__.Class', spec=True)974>>> MockClass = patcher.start()975>>> instance = MockClass()976>>> assert isinstance(instance, Original)977>>> patcher.stop()978```979980Аргумент *new\_callable* полезен, когда требуется использовать альтернативный класс вместо [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) по умолчанию для создаваемого мока. Например, если нужно использовать [`NonCallableMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.NonCallableMock):981982```python983>>> thing = object()984>>> with patch('__main__.thing', new_callable=NonCallableMock) as mock_thing:985...     assert thing is mock_thing986...     thing()987...988Traceback (most recent call last):989  ...990TypeError: 'NonCallableMock' object is not callable991```992993Ещё один вариант использования – замена объекта на экземпляр [`io.StringIO`](https://python-all.ru/3.7/library/io.html#io.StringIO):994995```python996>>> from io import StringIO997>>> def foo():998...     print('Something')999...1000>>> @patch('sys.stdout', new_callable=StringIO)1001... def test(mock_stdout):1002...     foo()1003...     assert mock_stdout.getvalue() == 'Something\n'1004...1005>>> test()1006```10071008Когда [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) создаёт мок, обычно первым делом нужно настроить мок. Часть этой настройки можно выполнить в вызове patch. Любые произвольные именованные аргументы, переданные в вызов, будут использованы для установки атрибутов созданного мока:10091010```python1011>>> patcher = patch('__main__.thing', first='one', second='two')1012>>> mock_thing = patcher.start()1013>>> mock_thing.first1014'one'1015>>> mock_thing.second1016'two'1017```10181019Помимо атрибутов созданного мока, такие атрибуты дочерних моков, как [`return_value`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.return_value) и [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), также можно настроить. Их нельзя передать напрямую как именованные аргументы, но словарь с такими ключами можно развернуть в вызов [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) с помощью `**`:10201021```python1022>>> config = {'method.return_value': 3, 'other.side_effect': KeyError}1023>>> patcher = patch('__main__.thing', **config)1024>>> mock_thing = patcher.start()1025>>> mock_thing.method()102631027>>> mock_thing.other()1028Traceback (most recent call last):1029  ...1030KeyError1031```10321033По умолчанию попытка запатчить несуществующую функцию в модуле (или метод, или атрибут в классе) завершится ошибкой [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError):10341035```python1036>>> @patch('sys.non_existing_attribute', 42)1037... def test():1038...     assert sys.non_existing_attribute == 421039...1040>>> test()1041Traceback (most recent call last):1042  ...1043AttributeError: <module 'sys' (built-in)> does not have the attribute 'non_existing'1044```10451046Но добавление `create=True` в вызов [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) заставит предыдущий пример работать как ожидается:10471048```python1049>>> @patch('sys.non_existing_attribute', 42, create=True)1050... def test(mock_stdout):1051...     assert sys.non_existing_attribute == 421052...1053>>> test()1054```10551056### patch.object10571058#### `patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`10591060Заменяет именованный член (*атрибут*) объекта (*цель*) на мок-объект.10611062[`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) можно использовать как декоратор, декоратор класса или менеджер контекста. Аргументы *new*, *spec*, *create*, *spec\_set*, *autospec* и *new\_callable* имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch). Как и [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), [`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) принимает произвольные именованные аргументы для настройки создаваемого мок-объекта.10631064При использовании в качестве декоратора класса [`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) учитывает `patch.TEST_PREFIX` для выбора методов, которые нужно обернуть.10651066[`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) можно вызывать с тремя или двумя аргументами. Форма с тремя аргументами принимает объект для патча, имя атрибута и объект, которым нужно заменить атрибут.10671068При вызове с двумя аргументами заменяющий объект опускается, и мок создаётся и передаётся как дополнительный аргумент в декорируемую функцию:10691070```python1071>>> @patch.object(SomeClass, 'class_method')1072... def test(mock_method):1073...     SomeClass.class_method(3)1074...     mock_method.assert_called_with(3)1075...1076>>> test()1077```10781079*spec*, *create* и остальные аргументы [`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch).10801081### patch.dict10821083#### `patch.dict(in_dict, values=(), clear=False, **kwargs)`10841085Исправляет словарь или подобный словарю объект и восстанавливает его исходное состояние после завершения теста.10861087*in\_dict* может быть словарём или контейнером, подобным отображению. Если это отображение, оно должно как минимум поддерживать получение, установку и удаление элементов, а также итерацию по ключам.10881089*in\_dict* также может быть строкой, задающей имя словаря, который затем будет получен через импорт.10901091*values* может быть словарём значений для установки в словаре. *values* также может быть итерируемым объектом пар `(key, value)`.10921093Если *clear* равен true, то словарь будет очищен перед установкой новых значений.10941095[`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) также можно вызывать с произвольными именованными аргументами для установки значений в словаре.10961097[`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) может использоваться как контекстный менеджер, декоратор или декоратор класса. При использовании в качестве декоратора класса [`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) учитывает `patch.TEST_PREFIX` для выбора методов, которые необходимо обернуть.10981099[`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) позволяет добавлять элементы в словарь или просто даёт тесту изменить словарь, гарантируя, что после завершения теста словарь будет восстановлен.11001101```python1102>>> foo = {}1103>>> with patch.dict(foo, {'newkey': 'newvalue'}):1104...     assert foo == {'newkey': 'newvalue'}1105...1106>>> assert foo == {}1107```11081109```python1110>>> import os1111>>> with patch.dict('os.environ', {'newkey': 'newvalue'}):1112...     print(os.environ['newkey'])1113...1114newvalue1115>>> assert 'newkey' not in os.environ1116```11171118Ключевые слова можно использовать в вызове [`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) для установки значений в словаре:11191120```python1121>>> mymodule = MagicMock()1122>>> mymodule.function.return_value = 'fish'1123>>> with patch.dict('sys.modules', mymodule=mymodule):1124...     import mymodule1125...     mymodule.function('some', 'args')1126...1127'fish'1128```11291130[`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) можно использовать с объектами, похожими на словари, но не являющимися словарями. Как минимум они должны поддерживать получение, установку и удаление элементов, а также либо итерацию, либо проверку принадлежности. Это соответствует магическим методам [`__getitem__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__getitem__), [`__setitem__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__setitem__), [`__delitem__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__delitem__) и либо [`__iter__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__iter__), либо [`__contains__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__contains__).11311132```python1133>>> class Container:1134...     def __init__(self):1135...         self.values = {}1136...     def __getitem__(self, name):1137...         return self.values[name]1138...     def __setitem__(self, name, value):1139...         self.values[name] = value1140...     def __delitem__(self, name):1141...         del self.values[name]1142...     def __iter__(self):1143...         return iter(self.values)1144...1145>>> thing = Container()1146>>> thing['one'] = 11147>>> with patch.dict(thing, one=2, two=3):1148...     assert thing['one'] == 21149...     assert thing['two'] == 31150...1151>>> assert thing['one'] == 11152>>> assert list(thing) == ['one']1153```11541155### patch.multiple11561157#### `patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)`11581159Выполняет несколько патчей за один вызов. Принимает объект для патча (либо сам объект, либо строку для его импорта) и именованные аргументы для патчей:11601161```python1162with patch.multiple(settings, FIRST_PATCH='one', SECOND_PATCH='two'):1163    ...1164```11651166Используйте [`DEFAULT`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.DEFAULT) в качестве значения, если хотите, чтобы [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) создавал моки автоматически. В этом случае созданные моки передаются в декорированную функцию по ключу, а при использовании [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) в качестве менеджера контекста возвращается словарь.11671168[`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) можно использовать как декоратор, декоратор класса или менеджер контекста. Аргументы *spec*, *spec\_set*, *create*, *autospec* и *new\_callable* имеют тот же смысл, что и для [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch). Эти аргументы применяются ко *всем* патчам, выполняемым с помощью [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple).11691170При использовании в качестве декоратора класса [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) учитывает `patch.TEST_PREFIX` для выбора методов, которые нужно обернуть.11711172Если требуется, чтобы [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) создавал моки автоматически, можно указать [`DEFAULT`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.DEFAULT) в качестве значения. При использовании [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) в качестве декоратора созданные моки передаются в декорированную функцию по ключу.11731174```python1175>>> thing = object()1176>>> other = object()1177```11781179```python1180>>> @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)1181... def test_function(thing, other):1182...     assert isinstance(thing, MagicMock)1183...     assert isinstance(other, MagicMock)1184...1185>>> test_function()1186```11871188[`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) можно вкладывать в другие декораторы `patch`, но аргументы, передаваемые по ключу, следует указывать *после* любых стандартных аргументов, созданных [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch):11891190```python1191>>> @patch('sys.exit')1192... @patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)1193... def test_function(mock_exit, other, thing):1194...     assert 'other' in repr(other)1195...     assert 'thing' in repr(thing)1196...     assert 'exit' in repr(mock_exit)1197...1198>>> test_function()1199```12001201Если [`patch.multiple()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.multiple) используется как менеджер контекста, возвращаемое им значение – это словарь, где созданные моки сгруппированы по имени:12021203```python1204>>> with patch.multiple('__main__', thing=DEFAULT, other=DEFAULT) as values:1205...     assert 'other' in repr(values['other'])1206...     assert 'thing' in repr(values['thing'])1207...     assert values['thing'] is thing1208...     assert values['other'] is other1209...1210```12111212### Методы patch: start и stop12131214У всех патчеров есть методы `start()` и `stop()`. Это упрощает применение патчей в методах `setUp` или в ситуациях, когда требуется выполнить несколько патчей без вложенных декораторов или операторов with.12151216Для их использования вызовите [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), [`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) или [`patch.dict()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.dict) как обычно и сохраните ссылку на возвращаемый объект `patcher`. Затем можно вызвать `start()`, чтобы применить патч, и `stop()`, чтобы его отменить.12171218Если [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) используется для создания мока, этот мок будет возвращён вызовом `patcher.start`.12191220```python1221>>> patcher = patch('package.module.ClassName')1222>>> from package import module1223>>> original = module.ClassName1224>>> new_mock = patcher.start()1225>>> assert module.ClassName is not original1226>>> assert module.ClassName is new_mock1227>>> patcher.stop()1228>>> assert module.ClassName is original1229>>> assert module.ClassName is not new_mock1230```12311232Типичный сценарий – выполнение нескольких патчей в методе `setUp` класса `TestCase`:12331234```python1235>>> class MyTest(TestCase):1236...     def setUp(self):1237...         self.patcher1 = patch('package.module.Class1')1238...         self.patcher2 = patch('package.module.Class2')1239...         self.MockClass1 = self.patcher1.start()1240...         self.MockClass2 = self.patcher2.start()1241...1242...     def tearDown(self):1243...         self.patcher1.stop()1244...         self.patcher2.stop()1245...1246...     def test_something(self):1247...         assert package.module.Class1 is self.MockClass11248...         assert package.module.Class2 is self.MockClass21249...1250>>> MyTest('test_something').run()1251```12521253> **Внимание**1254>1255> При использовании этой техники необходимо убедиться, что патч «отменён» вызовом `stop`. Это может быть сложнее, чем кажется, потому что если в методе `setUp` возникнет исключение, `tearDown` не будет вызван. [`unittest.TestCase.addCleanup()`](https://python-all.ru/3.7/library/unittest.html#unittest.TestCase.addCleanup) упрощает задачу:1256>1257> ```python1258> >>> class MyTest(TestCase):1259> ...     def setUp(self):1260> ...         patcher = patch('package.module.Class')1261> ...         self.MockClass = patcher.start()1262> ...         self.addCleanup(patcher.stop)1263> ...1264> ...     def test_something(self):1265> ...         assert package.module.Class is self.MockClass1266> ...1267> ```1268>1269> В качестве дополнительного бонуса больше не нужно хранить ссылку на объект `patcher`.12701271Также можно остановить все запущенные патчи с помощью [`patch.stopall()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.stopall).12721273#### `patch.stopall()`12741275Останавливает все активные патчи. Останавливает только те патчи, которые были запущены с помощью `start`.12761277### Патчинг встроенных функций: patch builtins12781279Можно патчить любые встроенные функции в модуле. В следующем примере патчится встроенная функция [`ord()`](https://python-all.ru/3.7/library/functions.html#ord):12801281```python1282>>> @patch('__main__.ord')1283... def test(mock_ord):1284...     mock_ord.return_value = 1011285...     print(ord('c'))1286...1287>>> test()12881011289```12901291### TEST\_PREFIX12921293Все патчеры можно использовать в качестве декораторов класса. В этом случае они оборачивают каждый тестовый метод класса. Патчеры распознают методы, начинающиеся с `'test'`, как тестовые. Это тот же принцип, по которому [`unittest.TestLoader`](https://python-all.ru/3.7/library/unittest.html#unittest.TestLoader) по умолчанию находит тестовые методы.12941295Возможно, потребуется использовать другой префикс для тестов. Уведомить патчеры о другом префиксе можно, установив `patch.TEST_PREFIX`:12961297```python1298>>> patch.TEST_PREFIX = 'foo'1299>>> value = 31300>>>1301>>> @patch('__main__.value', 'not three')1302... class Thing:1303...     def foo_one(self):1304...         print(value)1305...     def foo_two(self):1306...         print(value)1307...1308>>>1309>>> Thing().foo_one()1310not three1311>>> Thing().foo_two()1312not three1313>>> value131431315```13161317### Вложенные декораторы патча13181319Если нужно выполнить несколько замен, можно просто наложить декораторы друг на друга.13201321Можно накладывать несколько декораторов патча, используя такой шаблон:13221323```python1324>>> @patch.object(SomeClass, 'class_method')1325... @patch.object(SomeClass, 'static_method')1326... def test(mock1, mock2):1327...     assert SomeClass.static_method is mock11328...     assert SomeClass.class_method is mock21329...     SomeClass.static_method('foo')1330...     SomeClass.class_method('bar')1331...     return mock1, mock21332...1333>>> mock1, mock2 = test()1334>>> mock1.assert_called_once_with('foo')1335>>> mock2.assert_called_once_with('bar')1336```13371338Обратите внимание: декораторы применяются снизу вверх. Это стандартный порядок применения декораторов в Python. Порядок созданных заглушек, передаваемых в тестовую функцию, соответствует этому порядку.13391340### Где применять патч13411342[`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) работает, временно заменяя объект, на который указывает *имя*, другим объектом. На один объект может указывать много имён, поэтому для корректной работы патча необходимо заменить имя, используемое тестируемой системой.13431344Основной принцип: патч применяется там, где объект *ищется*, а это не обязательно то же место, где он определён. Несколько примеров помогут прояснить это.13451346Представим проект, который нужно протестировать, со следующей структурой:13471348```python1349a.py1350    -> Defines SomeClass13511352b.py1353    -> from a import SomeClass1354    -> some_function instantiates SomeClass1355```13561357Теперь мы хотим протестировать `some_function`, но подменить `SomeClass` с помощью [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch). Проблема в том, что когда мы импортируем модуль b (а нам придётся это сделать), он импортирует `SomeClass` из модуля a. Если мы используем [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) для подмены `a.SomeClass`, это не повлияет на наш тест: модуль b уже имеет ссылку на *настоящий* `SomeClass`, и может показаться, что наша подмена не сработала.13581359Ключ в том, чтобы заменить `SomeClass` там, где он используется (или где происходит поиск). В этом случае `some_function` будет искать `SomeClass` в модуле b, куда он был импортирован. Замена должна выглядеть так:13601361```python1362@patch('b.SomeClass')1363```13641365Однако рассмотрим альтернативный сценарий: вместо `from a import SomeClass` модуль b выполняет `import a`, и `some_function` использует `a.SomeClass`. Обе формы импорта распространены. В этом случае класс, который нужно заменить, ищется в модуле, поэтому заменять нужно `a.SomeClass`:13661367```python1368@patch('a.SomeClass')1369```13701371### Замена дескрипторов и прокси-объектов13721373И [patch](https://python-all.ru/3.7/library/unittest.mock.html#patch), и [patch.object](https://python-all.ru/3.7/library/unittest.mock.html#patch-object) корректно заменяют и восстанавливают дескрипторы: методы класса, статические методы и свойства. Заменять их следует на *классе*, а не на экземпляре. Они также работают с *некоторыми* объектами, проксирующими доступ к атрибутам, например, [объект настроек Django](https://python-all.ru/3.7/library/unittest.mock.html).13741375## MagicMock и поддержка магических методов13761377### Подмена магических методов13781379[`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) поддерживает имитацию методов протоколов Python, также известных как «магические методы». Это позволяет имитирующим объектам заменять контейнеры или другие объекты, реализующие протоколы Python.13801381Поскольку магические методы ищутся иначе, чем обычные методы [2](https://python-all.ru/3.7/library/unittest.mock.html#id8), эта поддержка была реализована специально. Это означает, что поддерживаются только определённые магические методы. Список поддерживаемых методов включает *почти* все. Если каких-то не хватает, пожалуйста, сообщите.13821383Магические методы подменяются установкой нужного метода в функцию или экземпляр заглушки. Если используется функция, она *должна* принимать `self` в качестве первого аргумента [3](https://python-all.ru/3.7/library/unittest.mock.html#id9).13841385```python1386>>> def __str__(self):1387...     return 'fooble'1388...1389>>> mock = Mock()1390>>> mock.__str__ = __str__1391>>> str(mock)1392'fooble'1393```13941395```python1396>>> mock = Mock()1397>>> mock.__str__ = Mock()1398>>> mock.__str__.return_value = 'fooble'1399>>> str(mock)1400'fooble'1401```14021403```python1404>>> mock = Mock()1405>>> mock.__iter__ = Mock(return_value=iter([]))1406>>> list(mock)1407[]1408```14091410Один из вариантов использования – подмена объектов, используемых как контекстные менеджеры в операторе [`with`](https://python-all.ru/3.7/reference/compound_stmts.html#with):14111412```python1413>>> mock = Mock()1414>>> mock.__enter__ = Mock(return_value='foo')1415>>> mock.__exit__ = Mock(return_value=False)1416>>> with mock as m:1417...     assert m == 'foo'1418...1419>>> mock.__enter__.assert_called_with()1420>>> mock.__exit__.assert_called_with(None, None, None)1421```14221423Вызовы магических методов не отображаются в [`method_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.method_calls), но записываются в [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls).14241425> **Примечание**1426>1427> Если при создании заглушки использовать именованный аргумент *spec*, то попытка установить магический метод, отсутствующий в спецификации, вызовет [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError).14281429Полный список поддерживаемых магических методов:14301431- `__hash__`, `__sizeof__`, `__repr__` и `__str__`1432- `__dir__`, `__format__` и `__subclasses__`1433- `__floor__`, `__trunc__` и `__ceil__`1434- Сравнения: `__lt__`, `__gt__`, `__le__`, `__ge__`, `__eq__` и `__ne__`1435- Методы контейнеров: `__getitem__`, `__setitem__`, `__delitem__`, `__contains__`, `__len__`, `__iter__`, `__reversed__` и `__missing__`1436- Контекстный менеджер: `__enter__` и `__exit__`1437- Унарные числовые методы: `__neg__`, `__pos__` и `__invert__`1438- Численные методы (включая варианты с правым операндом и на месте): `__add__`, `__sub__`, `__mul__`, `__matmul__`, `__div__`, `__truediv__`, `__floordiv__`, `__mod__`, `__divmod__`, `__lshift__`, `__rshift__`, `__and__`, `__xor__`, `__or__` и `__pow__`1439- Методы числового преобразования: `__complex__`, `__int__`, `__float__` и `__index__`1440- Методы дескрипторов: `__get__`, `__set__` и `__delete__`1441- Сериализация (pickling): `__reduce__`, `__reduce_ex__`, `__getinitargs__`, `__getnewargs__`, `__getstate__` и `__setstate__`14421443Следующие методы существуют, но *не* поддерживаются, так как либо используются в mock, либо не могут быть установлены динамически, либо могут вызывать проблемы:14441445- `__getattr__`, `__setattr__`, `__init__` и `__new__`1446- `__prepare__`, `__instancecheck__`, `__subclasscheck__`, `__del__`14471448### Магический макет14491450Существует два `MagicMock` варианта: [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) и [`NonCallableMagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.NonCallableMagicMock).14511452#### `class unittest.mock.MagicMock(*args, **kw)`14531454`MagicMock` является подклассом [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) с реализациями по умолчанию большинства магических методов. Можно использовать `MagicMock` без необходимости настраивать магические методы самостоятельно.14551456Параметры конструктора имеют тот же смысл, что и для [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock).14571458Если используются аргументы *spec* или *spec\_set*, то будут созданы *только* магические методы, которые существуют в спецификации.14591460#### `class unittest.mock.NonCallableMagicMock(*args, **kw)`14611462Невызываемая версия [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock).14631464Параметры конструктора имеют тот же смысл, что и для [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock), за исключением *return\_value* и *side\_effect*, которые не имеют смысла для невызываемого mock.14651466Магические методы настраиваются с помощью объектов [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock), поэтому их можно настраивать и использовать обычным образом:14671468```python1469>>> mock = MagicMock()1470>>> mock[3] = 'fish'1471>>> mock.__setitem__.assert_called_with(3, 'fish')1472>>> mock.__getitem__.return_value = 'result'1473>>> mock[2]1474'result'1475```14761477По умолчанию многие методы протокола должны возвращать объекты определенного типа. Эти методы предварительно настроены с возвращаемым значением по умолчанию, так что их можно использовать, ничего не делая, если возвращаемое значение не интересует. Вы всё еще можете *установить* возвращаемое значение вручную, если хотите изменить значение по умолчанию.14781479Методы и их значения по умолчанию:14801481- `__lt__`: `NotImplemented`1482- `__gt__`: `NotImplemented`1483- `__le__`: `NotImplemented`1484- `__ge__`: `NotImplemented`1485- `__int__`: `1`1486- `__contains__`: `False`1487- `__len__`: `0`1488- `__iter__`: `iter([])`1489- `__exit__`: `False`1490- `__complex__`: `1j`1491- `__float__`: `1.0`1492- `__bool__`: `True`1493- `__index__`: `1`1494- `__hash__`: хэш по умолчанию для mock1495- `__str__`: строковое представление по умолчанию для mock1496- `__sizeof__`: размер по умолчанию для mock14971498Например:14991500```python1501>>> mock = MagicMock()1502>>> int(mock)150311504>>> len(mock)150501506>>> list(mock)1507[]1508>>> object() in mock1509False1510```15111512Два метода сравнения, [`__eq__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__eq__) и [`__ne__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__ne__), являются особенными. Они выполняют сравнение на равенство по умолчанию по идентичности, используя атрибут [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), если не изменить их возвращаемое значение на что-то другое:15131514```python1515>>> MagicMock() == 31516False1517>>> MagicMock() != 31518True1519>>> mock = MagicMock()1520>>> mock.__eq__.return_value = True1521>>> mock == 31522True1523```15241525Возвращаемое значение `MagicMock.__iter__()` может быть любым итерируемым объектом и не обязательно должно быть итератором:15261527```python1528>>> mock = MagicMock()1529>>> mock.__iter__.return_value = ['a', 'b', 'c']1530>>> list(mock)1531['a', 'b', 'c']1532>>> list(mock)1533['a', 'b', 'c']1534```15351536Если возвращаемое значение *является* итератором, то однократная итерация по нему израсходует его, и последующие итерации приведут к пустому списку:15371538```python1539>>> mock.__iter__.return_value = iter(['a', 'b', 'c'])1540>>> list(mock)1541['a', 'b', 'c']1542>>> list(mock)1543[]1544```15451546`MagicMock` имеет все поддерживаемые магические методы, настроенные, за исключением некоторых малоизвестных и устаревших. Вы всё еще можете настроить их, если захотите.15471548Магические методы, которые поддерживаются, но не настроены по умолчанию в `MagicMock`:15491550- `__subclasses__`1551- `__dir__`1552- `__format__`1553- `__get__`, `__set__` и `__delete__`1554- `__reversed__` и `__missing__`1555- `__reduce__`, `__reduce_ex__`, `__getinitargs__`, `__getnewargs__`, `__getstate__` и `__setstate__`1556- `__getformat__` и `__setformat__`15571558**[2](https://python-all.ru/3.7/library/unittest.mock.html#id6)**15591560Магические методы *должны* искаться в классе, а не в экземпляре. Разные версии Python непоследовательны в применении этого правила. Поддерживаемые методы протокола должны работать во всех поддерживаемых версиях Python.15611562**[3](https://python-all.ru/3.7/library/unittest.mock.html#id7)**15631564Функция в основном привязана к классу, но каждый экземпляр `Mock` изолирован от остальных.15651566## Вспомогательные функции15671568### sentinel15691570#### `unittest.mock.sentinel`15711572Объект `sentinel` предоставляет удобный способ создания уникальных объектов для тестов.15731574Атрибуты создаются по запросу при обращении к ним по имени. Обращение к одному и тому же атрибуту всегда возвращает один и тот же объект. Возвращаемые объекты имеют понятное строковое представление (repr), чтобы сообщения об ошибках тестов были читаемыми.15751576Изменено в версии 3.7: Атрибуты `sentinel` теперь сохраняют свою идентичность при их [`copied`](https://python-all.ru/3.7/library/copy.html#module-copy) или [`pickled`](https://python-all.ru/3.7/library/pickle.html#module-pickle).15771578Иногда при тестировании нужно проверить, что определённый объект передаётся как аргумент другому методу или возвращается. Часто для этого создают именованные sentinel-объекты. [`sentinel`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.sentinel) предоставляет удобный способ создания и проверки идентичности таких объектов.15791580В этом примере мы применяем монки-патчинг к `method`, чтобы он возвращал `sentinel.some_object`:15811582```python1583>>> real = ProductionClass()1584>>> real.method = Mock(name="method")1585>>> real.method.return_value = sentinel.some_object1586>>> result = real.method()1587>>> assert result is sentinel.some_object1588>>> sentinel.some_object1589sentinel.some_object1590```15911592### DEFAULT15931594#### `unittest.mock.DEFAULT`15951596Объект [`DEFAULT`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.DEFAULT) – это предварительно созданный sentinel (фактически `sentinel.DEFAULT`). Он может использоваться функциями [`side_effect`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.side_effect), чтобы указать, что следует использовать обычное возвращаемое значение.15971598### call15991600#### `unittest.mock.call(*args, **kwargs)`16011602[`call()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call) – это вспомогательный объект для упрощения утверждений, для сравнения с [`call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args), [`call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list), [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) и [`method_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.method_calls). [`call()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call) также можно использовать с [`assert_has_calls()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_has_calls).16031604```python1605>>> m = MagicMock(return_value=None)1606>>> m(1, 2, a='foo', b='bar')1607>>> m()1608>>> m.call_args_list == [call(1, 2, a='foo', b='bar'), call()]1609True1610```16111612#### `call.call_list()`16131614Для объекта call, представляющего несколько вызовов, [`call_list()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call.call_list) возвращает список всех промежуточных вызовов, а также финального вызова.16151616`call_list` особенно полезен для проверки «цепочных вызовов». Цепочный вызов – это несколько вызовов в одной строке кода. В результате в [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls) макета появляется несколько записей. Ручное построение последовательности вызовов может быть утомительным.16171618[`call_list()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.call.call_list) может построить последовательность вызовов из того же цепочного вызова:16191620```python1621>>> m = MagicMock()1622>>> m(1).method(arg='foo').other('bar')(2.0)1623<MagicMock name='mock().method().other()()' id='...'>1624>>> kall = call(1).method(arg='foo').other('bar')(2.0)1625>>> kall.call_list()1626[call(1),1627 call().method(arg='foo'),1628 call().method().other('bar'),1629 call().method().other()(2.0)]1630>>> m.mock_calls == kall.call_list()1631True1632```16331634Объект `call` представляет собой либо кортеж (позиционные аргументы, именованные аргументы), либо (имя, позиционные аргументы, именованные аргументы) в зависимости от того, как он был создан. При самостоятельном создании это не особо важно, но объекты `call`, находящиеся в атрибутах [`Mock.call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args), [`Mock.call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list) и [`Mock.mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls), можно интроспектировать, чтобы получить отдельные аргументы, которые они содержат.16351636Объекты `call` в [`Mock.call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args) и [`Mock.call_args_list`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args_list) представляют собой кортежи из двух элементов (позиционные аргументы, именованные аргументы), тогда как объекты `call` в [`Mock.mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls), а также создаваемые вручную, являются кортежами из трёх элементов (имя, позиционные аргументы, именованные аргументы).16371638Вы можете использовать их «кортежность», чтобы извлекать отдельные аргументы для более сложной интроспекции и проверок. Позиционные аргументы – это кортеж (пустой кортеж, если позиционных аргументов нет), а именованные аргументы – это словарь:16391640```python1641>>> m = MagicMock(return_value=None)1642>>> m(1, 2, 3, arg='one', arg2='two')1643>>> kall = m.call_args1644>>> args, kwargs = kall1645>>> args1646(1, 2, 3)1647>>> kwargs1648{'arg2': 'two', 'arg': 'one'}1649>>> args is kall[0]1650True1651>>> kwargs is kall[1]1652True1653```16541655```python1656>>> m = MagicMock()1657>>> m.foo(4, 5, 6, arg='two', arg2='three')1658<MagicMock name='mock.foo()' id='...'>1659>>> kall = m.mock_calls[0]1660>>> name, args, kwargs = kall1661>>> name1662'foo'1663>>> args1664(4, 5, 6)1665>>> kwargs1666{'arg2': 'three', 'arg': 'two'}1667>>> name is m.mock_calls[0][0]1668True1669```16701671### create\_autospec16721673#### `unittest.mock.create_autospec(spec, spec_set=False, instance=False, **kwargs)`16741675Создаёт макет-объект, используя другой объект в качестве спецификации. Атрибуты макета будут использовать соответствующий атрибут объекта *spec* в качестве своей спецификации.16761677У макетируемых функций или методов будут проверяться аргументы, чтобы убедиться, что они вызываются с правильной сигнатурой.16781679Если *spec\_set* равен `True`, то попытка установить атрибуты, которых нет в объекте спецификации, вызовет исключение [`AttributeError`](https://python-all.ru/3.7/library/exceptions.html#AttributeError).16801681Если в качестве спецификации используется класс, то возвращаемое значение макета (экземпляр класса) будет иметь ту же спецификацию. Вы можете использовать класс в качестве спецификации для объекта-экземпляра, передав `instance=True`. Возвращаемый макет будет вызываемым, только если экземпляры макета вызываемы.16821683[`create_autospec()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.create_autospec) также принимает произвольные именованные аргументы, которые передаются конструктору создаваемого макета.16841685Смотрите [Autospeccing](https://python-all.ru/3.7/library/unittest.mock.html#auto-speccing) для примеров использования автоспецификации с [`create_autospec()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.create_autospec) и аргументом *autospec* для [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch).16861687### ANY16881689#### `unittest.mock.ANY`16901691Иногда может потребоваться сделать утверждения о *некоторых* аргументах вызова макета, но либо некоторые аргументы не важны, либо нужно извлечь их по отдельности из [`call_args`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.call_args) и сделать более сложные проверки.16921693Чтобы игнорировать определённые аргументы, можно передавать объекты, которые сравниваются равными с *чем угодно*. Вызовы [`assert_called_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with) тогда будут успешными независимо от того, что было передано.16941695```python1696>>> mock = Mock(return_value=None)1697>>> mock('foo', bar=object())1698>>> mock.assert_called_once_with('foo', bar=ANY)1699```17001701[`ANY`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.ANY) также можно использовать в сравнениях со списками вызовов, например: [`mock_calls`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.mock_calls):17021703```python1704>>> m = MagicMock(return_value=None)1705>>> m(1)1706>>> m(1, 2)1707>>> m(object())1708>>> m.mock_calls == [call(1), call(1, 2), ANY]1709True1710```17111712### FILTER\_DIR17131714#### `unittest.mock.FILTER_DIR`17151716[`FILTER_DIR`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.FILTER_DIR) – это переменная уровня модуля, которая управляет тем, как имитирующие объекты реагируют на [`dir()`](https://python-all.ru/3.7/library/functions.html#dir) (только для Python 2.6 и новее). Значение по умолчанию – `True`, которое использует фильтрацию, описанную ниже, чтобы показывать только полезные члены. Если вам не нравится такая фильтрация, или её нужно отключить для диагностики, установите `mock.FILTER_DIR = False`.17171718При включённой фильтрации `dir(some_mock)` показывает только полезные атрибуты и будет включать любые динамически созданные атрибуты, которые обычно не отображаются. Если mock был создан с *spec* (или, конечно, *autospec*), то показываются все атрибуты оригинала, даже если к ним ещё не обращались:17191720```python1721>>> dir(Mock())1722['assert_any_call',1723 'assert_called_once_with',1724 'assert_called_with',1725 'assert_has_calls',1726 'attach_mock',1727 ...1728>>> from urllib import request1729>>> dir(Mock(spec=request))1730['AbstractBasicAuthHandler',1731 'AbstractDigestAuthHandler',1732 'AbstractHTTPHandler',1733 'BaseHandler',1734 ...1735```17361737Многие не очень полезные атрибуты (приватные для [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), а не для того, что имитируется) с префиксом из одного или двух подчёркиваний были отфильтрованы из результата вызова [`dir()`](https://python-all.ru/3.7/library/functions.html#dir) на [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock). Если вам не нравится такое поведение, вы можете отключить его, установив переключатель уровня модуля [`FILTER_DIR`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.FILTER_DIR):17381739```python1740>>> from unittest import mock1741>>> mock.FILTER_DIR = False1742>>> dir(mock.Mock())1743['_NonCallableMock__get_return_value',1744 '_NonCallableMock__get_side_effect',1745 '_NonCallableMock__return_value_doc',1746 '_NonCallableMock__set_return_value',1747 '_NonCallableMock__set_side_effect',1748 '__call__',1749 '__class__',1750 ...1751```17521753В качестве альтернативы вы можете просто использовать `vars(my_mock)` (атрибуты экземпляра) и `dir(type(my_mock))` (атрибуты типа), чтобы обойти фильтрацию независимо от `mock.FILTER_DIR`.17541755### mock\_open17561757#### `unittest.mock.mock_open(mock=None, read_data=None)`17581759Вспомогательная функция для создания mock для замены использования [`open()`](https://python-all.ru/3.7/library/functions.html#open). Она работает для [`open()`](https://python-all.ru/3.7/library/functions.html#open), вызываемого напрямую или используемого как контекстный менеджер.17601761Аргумент *mock* – это настраиваемый объект mock. Если `None` (по умолчанию), то для вас будет создан [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) с API, ограниченным методами или атрибутами, доступными у стандартных файловых дескрипторов.17621763*read\_data* – это строка, которую методы `read()`, [`readline()`](https://python-all.ru/3.7/library/io.html#io.IOBase.readline) и [`readlines()`](https://python-all.ru/3.7/library/io.html#io.IOBase.readlines) файлового хендла должны возвращать. Вызовы этих методов будут брать данные из *read\_data*, пока она не исчерпается. Mock этих методов довольно примитивен: каждый раз при вызове *mock* *read\_data* перематывается к началу. Если вам нужен больший контроль над данными, которые вы передаёте тестируемому коду, вам придётся настроить этот mock самостоятельно. Если этого недостаточно, один из пакетов для файловой системы в памяти на [PyPI](https://python-all.ru/3.7/library/unittest.mock.html) может предложить реалистичную файловую систему для тестирования.17641765Изменено в версии 3.4: Добавлена поддержка [`readline()`](https://python-all.ru/3.7/library/io.html#io.IOBase.readline) и [`readlines()`](https://python-all.ru/3.7/library/io.html#io.IOBase.readlines). Mock для `read()` изменён – теперь он потребляет *read\_data*, а не возвращает её при каждом вызове.17661767Изменено в версии 3.5: Теперь *read\_data* сбрасывается при каждом вызове *mock*.17681769Изменено в версии 3.7.1: добавлен [`__iter__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__iter__) в реализацию, чтобы итерация (например, в циклах for loops) корректно потребляла *read\_data*.17701771Использование [`open()`](https://python-all.ru/3.7/library/functions.html#open) как контекстного менеджера – отличный способ гарантировать, что ваши файловые хендлы будут правильно закрыты, и это становится всё более распространённым:17721773```python1774with open('/some/path', 'w') as f:1775    f.write('something')1776```17771778Проблема в том, что даже если вы замокаете вызов [`open()`](https://python-all.ru/3.7/library/functions.html#open), именно *возвращаемый объект* используется как контекстный менеджер (и у него вызываются [`__enter__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__exit__)).17791780Мокать контекстные менеджеры с помощью [`MagicMock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.MagicMock) достаточно распространено и замороченно, поэтому вспомогательная функция полезна.17811782```python1783>>> m = mock_open()1784>>> with patch('__main__.open', m):1785...     with open('foo', 'w') as h:1786...         h.write('some stuff')1787...1788>>> m.mock_calls1789[call('foo', 'w'),1790 call().__enter__(),1791 call().write('some stuff'),1792 call().__exit__(None, None, None)]1793>>> m.assert_called_once_with('foo', 'w')1794>>> handle = m()1795>>> handle.write.assert_called_once_with('some stuff')1796```17971798А для чтения файлов:17991800```python1801>>> with patch('__main__.open', mock_open(read_data='bibble')) as m:1802...     with open('foo') as h:1803...         result = h.read()1804...1805>>> m.assert_called_once_with('foo')1806>>> assert result == 'bibble'1807```18081809### Автоспецификация18101811Autospeccing основан на существующей `spec` функции mock. Он ограничивает API mock-объектов API исходного объекта (spec), но является рекурсивным (реализован лениво), поэтому атрибуты mock имеют только те же API, что и атрибуты spec. Кроме того, замоканные функции/методы имеют ту же сигнатуру вызова, что и оригинал, поэтому они вызывают [`TypeError`](https://python-all.ru/3.7/library/exceptions.html#TypeError), если вызваны неправильно.18121813Прежде чем я объясню, как работает автоспекинг, вот почему он нужен.18141815[`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) – очень мощный и гибкий объект, но у него есть два недостатка при использовании для подмены объектов тестируемой системы. Один из них относится к API [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock), а другой – более общая проблема использования mock-объектов.18161817Сначала проблема, специфичная для [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock). У [`Mock`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock) есть два очень удобных метода assert: [`assert_called_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_with) и [`assert_called_once_with()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.Mock.assert_called_once_with).18181819```python1820>>> mock = Mock(name='Thing', return_value=None)1821>>> mock(1, 2, 3)1822>>> mock.assert_called_once_with(1, 2, 3)1823>>> mock(1, 2, 3)1824>>> mock.assert_called_once_with(1, 2, 3)1825Traceback (most recent call last):1826 ...1827AssertionError: Expected 'mock' to be called once. Called 2 times.1828```18291830Поскольку mock-объекты автоматически создают атрибуты по требованию и позволяют вызывать их с произвольными аргументами, опечатка в имени одного из этих методов проверок приводит к тому, что проверка просто исчезает:18311832```pycon1833>>> mock = Mock(name='Thing', return_value=None)1834>>> mock(1, 2, 3)1835>>> mock.assret_called_once_with(4, 5, 6)1836```18371838Из-за опечатки тесты могут проходить молча и неправильно.18391840The 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.18411842Обратите внимание, что это ещё одна причина, по которой нужны интеграционные тесты, а не только модульные. Тестировать всё изолированно – это хорошо, но если вы не тестируете, как ваши модули «соединены вместе», всё ещё остаётся много места для ошибок, которые тесты могли бы выявить.18431844`mock` уже предоставляет функцию для этого, называемую speccing. Если вы используете класс или экземпляр в качестве `spec` для mock, то вы можете получить доступ только к тем атрибутам mock, которые существуют в реальном классе:18451846```python1847>>> from urllib import request1848>>> mock = Mock(spec=request.Request)1849>>> mock.assret_called_with1850Traceback (most recent call last):1851 ...1852AttributeError: Mock object has no attribute 'assret_called_with'1853```18541855Spec применяется только к самому mock, поэтому у нас всё ещё есть та же проблема с любыми методами на mock:18561857```pycon1858>>> mock.has_data()1859<mock.Mock object at 0x...>1860>>> mock.has_data.assret_called_with()1861```18621863Auto-speccing решает эту проблему. Вы можете передать `autospec=True` в [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) / [`patch.object()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch.object) или использовать функцию [`create_autospec()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.create_autospec), чтобы создать mock с spec. Если вы используете аргумент `autospec=True` для [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), то заменяемый объект будет использоваться как объект spec. Поскольку speccing выполняется «лениво» (spec создаётся по мере доступа к атрибутам mock), вы можете использовать его с очень сложными или глубоко вложенными объектами (например, модулями, которые импортируют модули, которые импортируют модули) без большого удара по производительности.18641865Вот пример его использования:18661867```python1868>>> from urllib import request1869>>> patcher = patch('__main__.request', autospec=True)1870>>> mock_request = patcher.start()1871>>> request is mock_request1872True1873>>> mock_request.Request1874<MagicMock name='request.Request' spec='Request' id='...'>1875```18761877Вы можете видеть, что у `request.Request` есть spec. `request.Request` принимает два аргумента в конструкторе (один из них – *self*). Вот что произойдёт, если мы попробуем вызвать его неправильно:18781879```python1880>>> req = request.Request()1881Traceback (most recent call last):1882 ...1883TypeError: <lambda>() takes at least 2 arguments (1 given)1884```18851886Spec также применяется к инстанцированным классам (т.е. возвращаемому значению specced-моков):18871888```python1889>>> req = request.Request('foo')1890>>> req1891<NonCallableMagicMock name='request.Request()' spec='Request' id='...'>1892```18931894Объекты `Request` не являются вызываемыми, поэтому возвращаемое значение при создании экземпляра нашей имитации `request.Request` – это невызываемая заглушка. При наличии спецификации любые опечатки в утверждениях вызовут правильное исключение:18951896```python1897>>> req.add_header('spam', 'eggs')1898<MagicMock name='request.Request().add_header()' id='...'>1899>>> req.add_header.assret_called_with1900Traceback (most recent call last):1901 ...1902AttributeError: Mock object has no attribute 'assret_called_with'1903>>> req.add_header.assert_called_with('spam', 'eggs')1904```19051906Во многих случаях достаточно добавить `autospec=True` к существующим вызовам [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), и это защитит от ошибок из-за опечаток и изменений API.19071908Помимо использования *autospec* через [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch), существует [`create_autospec()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.create_autospec) для создания autospec-моков напрямую:19091910```python1911>>> from urllib import request1912>>> mock_request = create_autospec(request)1913>>> mock_request.Request('foo', 'bar')1914<NonCallableMagicMock name='mock.Request()' spec='Request' id='...'>1915```19161917Однако у этого подхода есть оговорки и ограничения, поэтому он не используется по умолчанию. Чтобы узнать, какие атрибуты доступны у объекта спецификации, autospec должен интроспектировать (получать доступ к атрибутам) спецификацию. Когда вы обращаетесь к атрибутам мока, под капотом происходит аналогичный обход оригинального объекта. Если у каких-то из ваших специфицированных объектов есть свойства или дескрипторы, которые могут запускать выполнение кода, то использовать autospec может не получиться. С другой стороны, гораздо лучше проектировать объекты так, чтобы интроспекция была безопасной [4](https://python-all.ru/3.7/library/unittest.mock.html#id11).19181919Более серьёзная проблема заключается в том, что атрибуты экземпляра часто создаются в методе [`__init__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__init__) и вообще не существуют на уровне класса. *autospec* не может знать о динамически созданных атрибутах и ограничивает API только видимыми атрибутами.19201921```python1922>>> class Something:1923...   def __init__(self):1924...     self.a = 331925...1926>>> with patch('__main__.Something', autospec=True):1927...   thing = Something()1928...   thing.a1929...1930Traceback (most recent call last):1931  ...1932AttributeError: Mock object has no attribute 'a'1933```19341935Существует несколько способов решить эту проблему. Самый простой (хотя и не обязательно наименее раздражающий) – просто установить нужные атрибуты на моке после его создания. То, что *autospec* не позволяет получать атрибуты, которых нет в спецификации, не мешает вам их устанавливать:19361937```python1938>>> with patch('__main__.Something', autospec=True):1939...   thing = Something()1940...   thing.a = 331941...1942```19431944Существует более строгая версия как *spec*, так и *autospec*, которая *не позволяет* устанавливать несуществующие атрибуты. Это полезно, если вы хотите гарантировать, что ваш код *устанавливает* только допустимые атрибуты, но, очевидно, это блокирует данный конкретный сценарий:19451946```python1947>>> with patch('__main__.Something', autospec=True, spec_set=True):1948...   thing = Something()1949...   thing.a = 331950...1951Traceback (most recent call last):1952 ...1953AttributeError: Mock object has no attribute 'a'1954```19551956Вероятно, лучший способ решения проблемы – добавить атрибуты класса в качестве значений по умолчанию для атрибутов экземпляра, инициализируемых в [`__init__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__init__). Обратите внимание, что если вы устанавливаете только атрибуты по умолчанию в [`__init__()`](https://python-all.ru/3.7/reference/datamodel.html#object.__init__), то предоставление их через атрибуты класса (общие для экземпляров, разумеется) также быстрее. Например:19571958```python1959class Something:1960    a = 331961```19621963Это поднимает ещё одну проблему. Довольно часто в качестве значения по умолчанию для членов, которые позже станут объектами другого типа, используется `None`. `None` была бы бесполезна в качестве спецификации, потому что не позволила бы обращаться *ни к каким* атрибутам или методам. Поскольку `None` *никогда* не будет полезна как спецификация и, вероятно, указывает на член, который обычно имеет другой тип, автоспецификация не использует спецификацию для членов, установленных в `None`. Они будут просто обычными заглушками (точнее, магическими заглушками):19641965```python1966>>> class Something:1967...     member = None1968...1969>>> mock = create_autospec(Something)1970>>> mock.member.foo.bar.baz()1971<MagicMock name='mock.member.foo.bar.baz()' id='...'>1972```19731974Если изменение ваших производственных классов для добавления значений по умолчанию вам не по душе, есть и другие варианты. Один из них – просто использовать экземпляр в качестве спецификации вместо класса. Другой – создать подкласс производственного класса и добавить значения по умолчанию в подкласс, не затрагивая производственный класс. Оба варианта требуют использования альтернативного объекта в качестве спецификации. К счастью, [`patch()`](https://python-all.ru/3.7/library/unittest.mock.html#unittest.mock.patch) поддерживает это – можно просто передать альтернативный объект в качестве аргумента *autospec*:19751976```python1977>>> class Something:1978...   def __init__(self):1979...     self.a = 331980...1981>>> class SomethingForTest(Something):1982...   a = 331983...1984>>> p = patch('__main__.Something', autospec=SomethingForTest)1985>>> mock = p.start()1986>>> mock.a1987<NonCallableMagicMock name='Something.a' spec='int' id='...'>1988```19891990**[4](https://python-all.ru/3.7/library/unittest.mock.html#id10)**19911992Это относится только к классам или уже созданным объектам. Вызов имитированного класса для создания экземпляра мока *не создаёт* реальный экземпляр. Выполняются только обращения к атрибутам – наряду с вызовами [`dir()`](https://python-all.ru/3.7/library/functions.html#dir).19931994### Запечатывание моков19951996#### `unittest.mock.seal(mock)`19971998Функция seal отключает автоматическое создание моков при обращении к атрибуту запечатываемого мока или рекурсивно к любым его атрибутам, которые уже являются моками.19992000Если экземпляру мока с именем или спецификацией присваивается атрибут, он не будет учитываться в цепочке запечатывания. Это позволяет предотвратить запечатывание части мок-объекта.20012002```python2003>>> mock = Mock()2004>>> mock.submock.attribute1 = 22005>>> mock.not_submock = mock.Mock(name="sample_name")2006>>> seal(mock)2007>>> mock.new_attribute  # Это вызовет AttributeError.2008>>> mock.submock.attribute2  # Это вызовет AttributeError.2009>>> mock.not_submock.attribute2  # Это не вызовет исключения.2010```20112012Добавлено в версии 3.7.2013