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-объект) или любое заданное значение возврата, это можно сделать двумя способами. Либо вернуть 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-объекта (или в качестве значения возврата), он становится его «дочерним» объектом. Вызовы дочернего объекта записываются в атрибуты родительского объекта 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-объекту именованные 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 не указан, цель заменяется на AsyncMock, если подменяемый объект является асинхронной функцией, или на MagicMock в остальных случаях. Если patch() используется как декоратор и new не указан, созданная имитация передаётся декорируемой функции в качестве дополнительного аргумента. Если patch() используется как менеджер контекста, созданная имитация возвращается менеджером контекста.

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. По умолчанию для асинхронных функций используется AsyncMock, а для остальных — MagicMock.

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

Вместо 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() создаёт имитацию.

patch() принимает произвольные именованные аргументы. Если подменяемый объект асинхронный, они будут переданы в AsyncMock, в остальных случаях — в MagicMock, а если указан 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_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)

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

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

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

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

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

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

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

patch.dict

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

patch.multiple

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

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

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

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

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

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

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

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

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

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

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

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

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

Методы patch: start и stop

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

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

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

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

Обычно этот подход используют, например, для выполнения нескольких подмен в методе setUp класса TestCase:

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

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

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

patch.stopall()

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

Подмена встроенных объектов

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

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

TEST_PREFIX

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

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

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

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

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

Несколько декораторов patch можно расположить друг за другом следующим образом:

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

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

Где выполнять подмену

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

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

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

a.py
    -> Defines SomeClass

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

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

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

@patch('b.SomeClass')

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

@patch('a.SomeClass')

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

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

Имитация магических методов

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

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

Чтобы имитировать магические методы, присвойте интересующий вас метод функции или экземпляру mock-объекта. Если вы используете функцию, она должна принимать 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__
• Сериализация с помощью pickle: __reduce__, __reduce_ex__, __getinitargs__, __getnewargs__, __getstate__ и __setstate__
• Представление пути файловой системы: __fspath__
• Методы асинхронной итерации: __aiter__ и __anext__

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

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

MagicMock

Существует два варианта 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
• __aexit__: 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

Возвращаемое значение __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 объекта mock появляется несколько записей. Вручную составлять последовательность вызовов может быть утомительно.

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)

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

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

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

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

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

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

ANY

unittest.mock.ANY

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

При включённой фильтрации dir(some_mock) показывает только полезные атрибуты, включая динамически созданные атрибуты, которые обычно не отображаются. Если объект 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',
 ...

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

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

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

mock_open

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

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

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

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

Изменено в версии 3.4: Добавлена поддержка readline() и readlines(). Поведение mock для 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 объектов mock API исходного объекта (спецификации), но делает это рекурсивно (лениво), поэтому атрибуты объектов mock имеют только тот же API, что и соответствующие атрибуты спецификации. Кроме того, имитируемые функции и методы имеют ту же сигнатуру вызова, что и оригинал, поэтому при неправильном вызове они вызывают исключение TypeError.

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

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

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

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

>>> 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, поэтому проблема с его методами остаётся:

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

Эту проблему решает автоматическое создание спецификаций. Можно передать autospec=True в patch() / patch.object() или использовать функцию create_autospec(), чтобы создать mock со спецификацией. Если передать аргумент autospec=True в patch(), заменяемый объект будет использоваться как объект спецификации. Поскольку спецификация создаётся «лениво» (по мере обращения к атрибутам 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 есть спецификация. request.Request принимает в конструкторе два аргумента (один из них — self). Вот что произойдёт при неправильном вызове:

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

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

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

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

>>> 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() для непосредственного создания mock с автоматической спецификацией:

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

Однако у этого подхода есть оговорки и ограничения, поэтому он не используется по умолчанию. Чтобы узнать, какие атрибуты доступны у объекта спецификации, autospec должен изучить спецификацию (обратиться к её атрибутам). При обходе атрибутов mock в фоновом режиме происходит соответствующий обход исходного объекта. Если у объектов со спецификацией есть свойства или дескрипторы, которые могут запускать код, использовать 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'

Есть несколько способов решить эту проблему. Самый простой, но не обязательно самый удобный, — задать нужные атрибуты объекту mock после его создания. То, что 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. Для них создаются обычные объекты mock (точнее, 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='...'>

Фиксация объектов mock

unittest.mock.seal(mock)

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

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

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