unittest.mock – библиотека mock-объектов¶unittest.mock – mock object library

Вызов ¶Calling

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

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

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

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

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

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

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

Если вы хотите, чтобы макет по-прежнему возвращал значение по умолчанию (новый макет) или любое заданное возвращаемое значение, есть два способа сделать это. Либо вернуть mock.return_value изнутри side_effect, либо вернуть DEFAULT:

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

Чтобы удалить side_effect и вернуться к поведению по умолчанию, установите side_effect в None:

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

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

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

Если какие-либо элементы итератора являются исключениями, они будут вызваны вместо того, чтобы быть возвращёнными:

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

Удаление атрибутов¶Deleting Attributes

Объекты Mock создают атрибуты по запросу. Это позволяет им притворяться объектами любого типа.

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

Вы «блокируете» атрибуты, удаляя их. После удаления доступ к атрибуту вызовет AttributeError.

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

Имена макетов и атрибут name¶Mock names and the name attribute

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

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

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

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

Прикрепление макетов в качестве атрибутов¶Attaching Mocks as Attributes

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

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

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

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

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

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

1

Единственное исключение – это магические методы и атрибуты (те, которые имеют двойные подчёркивания в начале и конце). Mock не создаёт их, а вместо этого вызывает AttributeError. Это связано с тем, что интерпретатор часто неявно запрашивает эти методы и очень путается, получая новый объект Mock, когда ожидает магический метод. Если вам нужна поддержка магических методов, обратитесь к магическим методам.

patch¶

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

patch() принимает произвольные именованные аргументы. Они будут переданы Mock (или new_callable) при создании.

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

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

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

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

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

Чтобы настроить возвращаемые значения для методов экземпляров патченного класса, это нужно делать на return_value. Например:

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

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

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

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

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

Ещё один вариант использования – замена объекта на экземпляр io.StringIO:

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

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

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

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

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

По умолчанию попытка запатчить несуществующую функцию в модуле (или метод, или атрибут в классе) завершится ошибкой AttributeError:

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

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

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

patch.object¶

patch.object(target, attribute, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)¶

Заменяет именованный член (атрибут) объекта (цель) на мок-объект.

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

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

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

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

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

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

patch.dict¶

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

Исправляет словарь или подобный словарю объект и восстанавливает его исходное состояние после завершения теста.

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

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

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

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

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

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

patch.dict() позволяет добавлять элементы в словарь или просто даёт тесту изменить словарь, гарантируя, что после завершения теста словарь будет восстановлен.

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

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

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

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

patch.dict() можно использовать с объектами, похожими на словари, но не являющимися словарями. Как минимум они должны поддерживать получение, установку и удаление элементов, а также либо итерацию, либо проверку принадлежности. Это соответствует магическим методам __getitem__(), __setitem__(), __delitem__() и либо __iter__(), либо __contains__().

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

patch.multiple¶

patch.multiple(target, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)¶

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

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

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

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

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

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

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

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

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

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

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

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

Методы patch: start и stop¶patch methods: start and stop

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

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

Если patch() используется для создания мока, этот мок будет возвращён вызовом patcher.start.

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

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

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

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

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

patch.stopall()¶

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

Патчинг встроенных функций: patch builtins¶patch builtins

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

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

TEST_PREFIX¶

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

Возможно, потребуется использовать другой префикс для тестов. Уведомить патчеры о другом префиксе можно, установив patch.TEST_PREFIX:

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

Вложенные декораторы патча¶Nesting Patch Decorators

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

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

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

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

Где применять патч¶Where to patch

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

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

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

a.py
    -> Defines SomeClass

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

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

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

@patch('b.SomeClass')

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

@patch('a.SomeClass')

Замена дескрипторов и прокси-объектов¶Patching Descriptors and Proxy Objects

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

Подмена магических методов¶Mocking Magic Methods

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

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

Магические методы подменяются установкой нужного метода в функцию или экземпляр заглушки. Если используется функция, она должна принимать self в качестве первого аргумента 3.

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

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

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

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

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

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

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

• __hash__, __sizeof__, __repr__ и __str__

• __dir__, __format__ и __subclasses__

• __floor__, __trunc__ и __ceil__

• Сравнения: __lt__, __gt__, __le__, __ge__, __eq__ и __ne__

• Методы контейнеров: __getitem__, __setitem__, __delitem__, __contains__, __len__, __iter__, __reversed__ и __missing__

• Контекстный менеджер: __enter__ и __exit__

• Унарные числовые методы: __neg__, __pos__ и __invert__

• Численные методы (включая варианты с правым операндом и на месте): __add__, __sub__, __mul__, __matmul__, __div__, __truediv__, __floordiv__, __mod__, __divmod__, __lshift__, __rshift__, __and__, __xor__, __or__ и __pow__

• Методы числового преобразования: __complex__, __int__, __float__ и __index__

• Методы дескрипторов: __get__, __set__ и __delete__

• Сериализация (pickling): __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__ и __setstate__

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

• __getattr__, __setattr__, __init__ и __new__

• __prepare__, __instancecheck__, __subclasscheck__, __del__

Магический макет¶Magic Mock

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

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

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

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

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

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

Невызываемая версия MagicMock.

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

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

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

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

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

• __lt__: NotImplemented

• __gt__: NotImplemented

• __le__: NotImplemented

• __ge__: NotImplemented

• __int__: 1

• __contains__: False

• __len__: 0

• __iter__: iter([])

• __exit__: False

• __complex__: 1j

• __float__: 1.0

• __bool__: True

• __index__: 1

• __hash__: хэш по умолчанию для mock

• __str__: строковое представление по умолчанию для mock

• __sizeof__: размер по умолчанию для mock

Например:

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

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

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

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

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

Если возвращаемое значение является итератором, то однократная итерация по нему израсходует его, и последующие итерации приведут к пустому списку:

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

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

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

• __subclasses__

• __dir__

• __format__

• __get__, __set__ и __delete__

• __reversed__ и __missing__

• __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__ и __setstate__

• __getformat__ и __setformat__

2

Магические методы должны искаться в классе, а не в экземпляре. Разные версии Python непоследовательны в применении этого правила. Поддерживаемые методы протокола должны работать во всех поддерживаемых версиях Python.

3

Функция в основном привязана к классу, но каждый экземпляр Mock изолирован от остальных.

sentinel¶

unittest.mock.sentinel¶

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

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

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

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

В этом примере мы применяем монки-патчинг к method, чтобы он возвращал sentinel.some_object:

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

DEFAULT¶

unittest.mock.DEFAULT¶

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

call¶

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

call() – это вспомогательный объект для упрощения утверждений, для сравнения с call_args, call_args_list, mock_calls и method_calls. call() также можно использовать с assert_has_calls().

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

call.call_list()¶

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

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

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

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

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

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

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

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

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

create_autospec¶

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

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

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

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

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

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

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

ANY¶

unittest.mock.ANY¶

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

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

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

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

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

FILTER_DIR¶

unittest.mock.FILTER_DIR¶

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

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

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

Многие не очень полезные атрибуты (приватные для Mock, а не для того, что имитируется) с префиксом из одного или двух подчёркиваний были отфильтрованы из результата вызова dir() на Mock. Если вам не нравится такое поведение, вы можете отключить его, установив переключатель уровня модуля FILTER_DIR:

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

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

mock_open¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Автоспецификация¶Autospeccing

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

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

Mock – очень мощный и гибкий объект, но у него есть два недостатка при использовании для подмены объектов тестируемой системы. Один из них относится к API Mock, а другой – более общая проблема использования mock-объектов.

Сначала проблема, специфичная для Mock. У Mock есть два очень удобных метода assert: assert_called_with() и assert_called_once_with().

>>> mock = Mock(name='Thing', return_value=None)
>>> mock(1, 2, 3)
>>> mock.assert_called_once_with(1, 2, 3)
>>> mock(1, 2, 3)
>>> mock.assert_called_once_with(1, 2, 3)
Traceback (most recent call last):
 ...
AssertionError: Expected 'mock' to be called once. Called 2 times.

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

>>> mock = Mock(name='Thing', return_value=None)
>>> mock(1, 2, 3)
>>> mock.assret_called_once_with(4, 5, 6)

Из-за опечатки тесты могут проходить молча и неправильно.

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

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

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

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

Spec применяется только к самому mock, поэтому у нас всё ещё есть та же проблема с любыми методами на mock:

>>> mock.has_data()
<mock.Mock object at 0x...>
>>> mock.has_data.assret_called_with()

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

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

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

Вы можете видеть, что у request.Request есть spec. request.Request принимает два аргумента в конструкторе (один из них – self). Вот что произойдёт, если мы попробуем вызвать его неправильно:

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

Spec также применяется к инстанцированным классам (т.е. возвращаемому значению specced-моков):

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

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

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

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

Помимо использования autospec через patch(), существует create_autospec() для создания autospec-моков напрямую:

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

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

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

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

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

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

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

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

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

class Something:
    a = 33

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

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

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

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

4

Это относится только к классам или уже созданным объектам. Вызов имитированного класса для создания экземпляра мока не создаёт реальный экземпляр. Выполняются только обращения к атрибутам – наряду с вызовами dir().

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

unittest.mock.seal(mock)¶

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

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

>>> mock = Mock()
>>> mock.submock.attribute1 = 2
>>> mock.not_submock = mock.Mock(name="sample_name")
>>> seal(mock)
>>> mock.new_attribute  # Это вызовет AttributeError.
>>> mock.submock.attribute2  # Это вызовет AttributeError.
>>> mock.not_submock.attribute2  # Это не вызовет исключения.

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