Насмешливый асинхронный вызов в python 3.5
Как смоделировать асинхронный вызов от одной родной сопрограммы к другой, используя unittest.mock.patch
?
У меня сейчас довольно неловкое решение:
class CoroutineMock(MagicMock):
def __await__(self, *args, **kwargs):
future = Future()
future.set_result(self)
result = yield from future
return result
затем
class TestCoroutines(TestCase):
@patch('some.path', new_callable=CoroutineMock)
def test(self, mock):
some_action()
mock.assert_called_with(1,2,3)
Это работает, но выглядит некрасиво. Есть ли еще питонский способ сделать это?
9 ответов
Наследование MagicMock
будет распространять ваш пользовательский класс для всех макетов, сгенерированных из вашего сопрограммного макета. Например, AsyncMock().__str__
также станет AsyncMock
что, вероятно, не то, что вы ищете.
Вместо этого вы можете определить фабрику, которая создает Mock
(или MagicMock
) с пользовательскими аргументами, например side_effect=coroutine(coro)
, Также может быть хорошей идеей отделить функцию сопрограммы от сопрограммы (как объяснено в документации).
Вот что я придумал:
from asyncio import coroutine
def CoroMock():
coro = Mock(name="CoroutineResult")
corofunc = Mock(name="CoroutineFunction", side_effect=coroutine(coro))
corofunc.coro = coro
return corofunc
Объяснение различных объектов:
corofunc
: макет функции сопрограммыcorofunc.side_effect()
: сопрограмма, генерируемая для каждого вызоваcorofunc.coro
: макет, используемый сопрограммой для получения результатаcorofunc.coro.return_value
: значение, возвращаемое сопрограммойcorofunc.coro.side_effect
: может использоваться для создания исключения
Пример:
async def coro(a, b):
return await sleep(1, result=a+b)
def some_action(a, b):
return get_event_loop().run_until_complete(coro(a, b))
@patch('__main__.coro', new_callable=CoroMock)
def test(corofunc):
a, b, c = 1, 2, 3
corofunc.coro.return_value = c
result = some_action(a, b)
corofunc.assert_called_with(a, b)
assert result == c
Решение было на самом деле довольно простым: мне просто нужно было конвертировать __call__
метод макета в сопрограмму:
class AsyncMock(MagicMock):
async def __call__(self, *args, **kwargs):
return super(AsyncMock, self).__call__(*args, **kwargs)
Это прекрасно работает, когда вызывается макет, код получает родную сопрограмму
Все упускают то, что, вероятно, самое простое и ясное решение:
@patch('some.path')
def test(self, mock):
f = asyncio.Future()
f.set_result('whatever result you want')
mock.return_value = f
mock.assert_called_with(1, 2, 3)
Помните, что сопрограмму можно рассматривать как функцию, гарантирующую возвращение будущего, которое, в свою очередь, можно ожидать.
Основываясь на ответе @scolvin, я создал этот (imo) более чистый способ:
def async_return(result):
f = asyncio.Future()
f.set_result(result)
return f
Вот и все, просто используйте его для любого возврата, который вы хотите сделать асинхронным, как в
mock = MagicMock(return_value=async_return("Example return"))
await mock()
У меня нет, почему никто не упомянул доступную опцию по умолчанию. python предоставляет асинхронную версию MagicMock.
Подробнее об этом можно прочитать здесь. https://docs.python.org/3/library/unittest.mock.html#unittest.mock.AsyncMock
Если вы используете патч, вам также не нужно вносить никаких других изменений. При необходимости он автоматически заменит его асинхронной фиктивной функцией. Подробнее читайте здесь https://docs.python.org/3/library/unittest.mock.html#patch
Еще один способ насмешливой сопрограммы - сделать сопрограмму, которая возвращает насмешку. Таким образом, вы можете высмеивать сопрограммы, которые будут переданы в asyncio.wait
или же asyncio.wait_for
,
Это делает более универсальные сопрограммы более сложными:
def make_coroutine(mock)
async def coroutine(*args, **kwargs):
return mock(*args, **kwargs)
return coroutine
class Test(TestCase):
def setUp(self):
self.coroutine_mock = Mock()
self.patcher = patch('some.coroutine',
new=make_coroutine(self.coroutine_mock))
self.patcher.start()
def tearDown(self):
self.patcher.stop()
Еще один вариант "простейшего" решения для макета асинхронного объекта, который представляет собой всего один слой.
В источнике:
class Yo:
async foo(self):
await self.bar()
async bar(self):
# Some code
В тесте:
from asyncio import coroutine
yo = Yo()
# Here bounded method bar is mocked and will return a customised result.
yo.bar = Mock(side_effect=coroutine(lambda:'the awaitable should return this'))
event_loop.run_until_complete(yo.foo())
Вы можете установить return_value
такого асинхронного метода:
mock = unittest.mock.MagicMock()
mock.your_async_method.return_value = task_from_result(your_return_value)
async def task_from_result(result):
return result
Вызывающий должен будет сделать await your_async_method(..)
точно так же, как если бы метод не был издевательством.
Мне нравится этот подход, который также заставляет AsyncMock вести себя точно так же, как Mock:
class AsyncMock:
def __init__(self, *args, **kwargs):
self.mock = Mock(*args, **kwargs)
async def __call__(self, *args, **kwargs):
return self.mock(*args, **kwargs)
def __getattr__(self, item):
return getattr(self.mock, item)
Затем вы можете работать с ним так же, как с Mock, то есть:
@pytest.mark.asyncio
async def test_async_mock_example(monkeypatch):
fn = AsyncMock(side_effect=ValueError)
with pytest.raises(ValueError):
await fn()
assert fn.call_count == 1