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

Вызов

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

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

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

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

>>> 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 всё равно возвращал значение по умолчанию (новый mock) или любое установленное возвращаемое значение, есть два способа. Либо верните 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 также может быть любым итерируемым объектом. Повторные вызовы Mock будут возвращать значения из итерируемого объекта (пока итерируемый объект не исчерпан и не возникает StopIteration):

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

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

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

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

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

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

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

Имена Mock и атрибут name

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

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

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

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

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

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

>>> 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 имеет имя. Это позволяет предотвратить «родительские» отношения, если по какой-либо причине этого не нужно.

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

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

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

patch

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

patch.object

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

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

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

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

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

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

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

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

patch.dict

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

Заменяет словарь или подобный ему объект и восстанавливает словарь до его первоначального состояния после теста.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

patch.multiple

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

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

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

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

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

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

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

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

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

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

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

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

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

методы патчей: start и stop

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

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

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

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

Типичный пример использования этого подхода — выполнение нескольких замещений в методе setUp объекта TestCase.

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

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

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

patch.stopall()

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

patch builtins

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

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

ПРЕФИКС_ТЕСТА

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

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

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

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

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

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

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

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

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

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

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

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

a.py
    -> Defines SomeClass

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

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

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

@patch('b.SomeClass')

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

@patch('a.SomeClass')

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Например:

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

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

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

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

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

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

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

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

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

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

sentinel

unittest.mock.sentinel

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

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

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

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

В этом примере мы переопределяем method для возврата sentinel.some_object.

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

DEFAULT

unittest.mock.DEFAULT

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

call

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

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

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

call.call_list()

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

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

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

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

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

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

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

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

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

create_autospec

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

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

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

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

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

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

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

ANY

unittest.mock.ANY

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

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

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

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

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

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

class TestStringMethods(unittest.TestCase):

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

FILTER_DIR

unittest.mock.FILTER_DIR

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

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

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

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

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

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

mock_open

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class Something:
    a = 33

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

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

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

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

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

unittest.mock.seal(mock)

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

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

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

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