Mocking async call in python 3.5
Everyone's missing what's probably the simplest and clearest solution:
@patch('some.path')
def test(self, mock):
f = asyncio.Future()
f.set_result('whatever result you want')
process_smtp_message.return_value = f
mock.assert_called_with(1, 2, 3)
remember a coroutine can be thought of as just a function which is guaranteed to return a future which can, in turn be awaited.
The solution was actually quite simple:
I just needed to convert __call__
method of mock into coroutine:
class AsyncMock(MagicMock):
async def __call__(self, *args, **kwargs):
return super(AsyncMock, self).__call__(*args, **kwargs)
This works perfectly, when mock is called, code receives native coroutine
Example usage:
@mock.patch('my.path.asyncio.sleep', new_callable=AsyncMock)
def test_stuff(sleep):
# code
Subclassing MagicMock
will propagate your custom class for all the mocks generated from your coroutine mock. For instance, AsyncMock().__str__
will also become an AsyncMock
which is probably not what you're looking for.
Instead, you might want to define a factory that creates a Mock
(or a MagicMock
) with custom arguments, for instance side_effect=coroutine(coro)
. Also, it might be a good idea to separate the coroutine function from the coroutine (as explained in the documentation).
Here is what I came up with:
from asyncio import coroutine
def CoroMock():
coro = Mock(name="CoroutineResult")
corofunc = Mock(name="CoroutineFunction", side_effect=coroutine(coro))
corofunc.coro = coro
return corofunc
An explanation of the different objects:
corofunc
: the coroutine function mockcorofunc.side_effect()
: the coroutine, generated for each callcorofunc.coro
: the mock used by the coroutine to get the resultcorofunc.coro.return_value
: the value returned by the coroutinecorofunc.coro.side_effect
: might be used to raise an exception
Example:
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
Based on @scolvin answer I created this (imo) cleaner way:
import asyncio
def async_return(result):
f = asyncio.Future()
f.set_result(result)
return f
That's it, just use it around whatever return you want to be async, as in
mock = MagicMock(return_value=async_return("Example return"))
await mock()