From 0a25a1d404dd8aab968e2b8aef870ad52c858dfc Mon Sep 17 00:00:00 2001 From: Miguel Grinberg Date: Sun, 24 Nov 2024 19:28:17 +0000 Subject: [PATCH] Adopt unittest.mock.AsyncMock in async unit tests --- tests/async/test_asgi.py | 182 ++++++------ tests/async/test_client.py | 575 ++++++++++++++++++------------------- tests/async/test_server.py | 81 +++--- tests/async/test_socket.py | 185 ++++++------ 4 files changed, 490 insertions(+), 533 deletions(-) diff --git a/tests/async/test_asgi.py b/tests/async/test_asgi.py index d23238a5..260281ba 100644 --- a/tests/async/test_asgi.py +++ b/tests/async/test_asgi.py @@ -5,17 +5,6 @@ from engineio.async_drivers import asgi as async_asgi -def AsyncMock(*args, **kwargs): - """Return a mock asynchronous function.""" - m = mock.MagicMock(*args, **kwargs) - - async def mock_coro(*args, **kwargs): - return m(*args, **kwargs) - - mock_coro.mock = m - return mock_coro - - def _run(coro): """Run the given coroutine.""" return asyncio.get_event_loop().run_until_complete(coro) @@ -36,70 +25,70 @@ def test_create_app(self): def test_engineio_routing(self): mock_server = mock.MagicMock() - mock_server.handle_request = AsyncMock() + mock_server.handle_request = mock.AsyncMock() app = async_asgi.ASGIApp(mock_server) scope = {'type': 'http', 'path': '/engine.io/'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/engine.io/'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/engine.iofoo/'} - _run(app(scope, 'receive', AsyncMock())) - mock_server.handle_request.mock.assert_not_called() + _run(app(scope, 'receive', mock.AsyncMock())) + mock_server.handle_request.assert_not_awaited() app = async_asgi.ASGIApp(mock_server, engineio_path=None) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/foo'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) app = async_asgi.ASGIApp(mock_server, engineio_path='mysocket.io') - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/mysocket.io'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/mysocket.io/'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/mysocket.io/foo'} _run(app(scope, 'receive', 'send')) - mock_server.handle_request.mock.assert_called_once_with( + mock_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send' ) - mock_server.handle_request.mock.reset_mock() + mock_server.handle_request.reset_mock() scope = {'type': 'http', 'path': '/mysocket.iofoo'} - _run(app(scope, 'receive', AsyncMock())) - mock_server.handle_request.mock.assert_not_called() + _run(app(scope, 'receive', mock.AsyncMock())) + mock_server.handle_request.assert_not_awaited() def test_other_app_routing(self): - other_app = AsyncMock() + other_app = mock.AsyncMock() app = async_asgi.ASGIApp('eio', other_app) scope = {'type': 'http', 'path': '/foo'} _run(app(scope, 'receive', 'send')) - other_app.mock.assert_called_once_with(scope, 'receive', 'send') + other_app.assert_awaited_once_with(scope, 'receive', 'send') def test_other_app_lifespan_routing(self): - other_app = AsyncMock() + other_app = mock.AsyncMock() app = async_asgi.ASGIApp('eio', other_app) scope = {'type': 'lifespan'} _run(app(scope, 'receive', 'send')) - other_app.mock.assert_called_once_with(scope, 'receive', 'send') + other_app.assert_awaited_once_with(scope, 'receive', 'send') def test_static_file_routing(self): root_dir = os.path.dirname(__file__) @@ -120,10 +109,10 @@ def test_static_file_routing(self): def check_path(path, status_code, content_type, body): scope = {'type': 'http', 'path': path} - receive = AsyncMock(return_value={'type': 'http.request'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'http.request'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_any_call( + send.assert_any_await( { 'type': 'http.response.start', 'status': status_code, @@ -132,7 +121,7 @@ def check_path(path, status_code, content_type, body): ], } ) - send.mock.assert_any_call( + send.assert_any_await( {'type': 'http.response.body', 'body': body.encode('utf-8')} ) @@ -185,11 +174,11 @@ def check_path(path, status_code, content_type, body): def test_lifespan_startup(self): app = async_asgi.ASGIApp('eio') scope = {'type': 'lifespan'} - receive = AsyncMock(side_effect=[{'type': 'lifespan.startup'}, - {'type': 'lifespan.shutdown'}]) - send = AsyncMock() + receive = mock.AsyncMock(side_effect=[{'type': 'lifespan.startup'}, + {'type': 'lifespan.shutdown'}]) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_any_call( + send.assert_any_await( {'type': 'lifespan.startup.complete'} ) @@ -202,11 +191,11 @@ def startup(): app = async_asgi.ASGIApp('eio', on_startup=startup) scope = {'type': 'lifespan'} - receive = AsyncMock(side_effect=[{'type': 'lifespan.startup'}, - {'type': 'lifespan.shutdown'}]) - send = AsyncMock() + receive = mock.AsyncMock(side_effect=[{'type': 'lifespan.startup'}, + {'type': 'lifespan.shutdown'}]) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_any_call( + send.assert_any_await( {'type': 'lifespan.startup.complete'} ) assert up @@ -220,11 +209,11 @@ async def startup(): app = async_asgi.ASGIApp('eio', on_startup=startup) scope = {'type': 'lifespan'} - receive = AsyncMock(side_effect=[{'type': 'lifespan.startup'}, - {'type': 'lifespan.shutdown'}]) - send = AsyncMock() + receive = mock.AsyncMock(side_effect=[{'type': 'lifespan.startup'}, + {'type': 'lifespan.shutdown'}]) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_any_call( + send.assert_any_await( {'type': 'lifespan.startup.complete'} ) assert up @@ -237,19 +226,19 @@ def startup(): app = async_asgi.ASGIApp('eio', on_startup=startup) scope = {'type': 'lifespan'} - receive = AsyncMock(side_effect=[{'type': 'lifespan.startup'}]) - send = AsyncMock() + receive = mock.AsyncMock(side_effect=[{'type': 'lifespan.startup'}]) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with({'type': 'lifespan.startup.failed'}) + send.assert_awaited_once_with({'type': 'lifespan.startup.failed'}) assert not up def test_lifespan_shutdown(self): app = async_asgi.ASGIApp('eio') scope = {'type': 'lifespan'} - receive = AsyncMock(return_value={'type': 'lifespan.shutdown'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'lifespan.shutdown'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with( + send.assert_awaited_once_with( {'type': 'lifespan.shutdown.complete'} ) @@ -262,10 +251,10 @@ def shutdown(): app = async_asgi.ASGIApp('eio', on_shutdown=shutdown) scope = {'type': 'lifespan'} - receive = AsyncMock(return_value={'type': 'lifespan.shutdown'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'lifespan.shutdown'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with( + send.assert_awaited_once_with( {'type': 'lifespan.shutdown.complete'} ) assert down @@ -279,10 +268,10 @@ async def shutdown(): app = async_asgi.ASGIApp('eio', on_shutdown=shutdown) scope = {'type': 'lifespan'} - receive = AsyncMock(return_value={'type': 'lifespan.shutdown'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'lifespan.shutdown'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with( + send.assert_awaited_once_with( {'type': 'lifespan.shutdown.complete'} ) assert down @@ -295,45 +284,45 @@ def shutdown(): app = async_asgi.ASGIApp('eio', on_shutdown=shutdown) scope = {'type': 'lifespan'} - receive = AsyncMock(return_value={'type': 'lifespan.shutdown'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'lifespan.shutdown'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with({'type': 'lifespan.shutdown.failed'}) + send.assert_awaited_once_with({'type': 'lifespan.shutdown.failed'}) assert not down def test_lifespan_invalid(self): app = async_asgi.ASGIApp('eio') scope = {'type': 'lifespan'} - receive = AsyncMock(side_effect=[{'type': 'lifespan.foo'}, - {'type': 'lifespan.shutdown'}]) - send = AsyncMock() + receive = mock.AsyncMock(side_effect=[{'type': 'lifespan.foo'}, + {'type': 'lifespan.shutdown'}]) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_called_once_with( + send.assert_awaited_once_with( {'type': 'lifespan.shutdown.complete'} ) def test_not_found(self): app = async_asgi.ASGIApp('eio') scope = {'type': 'http', 'path': '/foo'} - receive = AsyncMock(return_value={'type': 'http.request'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'http.request'}) + send = mock.AsyncMock() _run(app(scope, receive, send)) - send.mock.assert_any_call( + send.assert_any_await( { 'type': 'http.response.start', 'status': 404, 'headers': [(b'Content-Type', b'text/plain')], } ) - send.mock.assert_any_call( + send.assert_any_await( {'type': 'http.response.body', 'body': b'Not Found'} ) def test_translate_request(self): - receive = AsyncMock( + receive = mock.AsyncMock( return_value={'type': 'http.request', 'body': b'hello world'} ) - send = AsyncMock() + send = mock.AsyncMock() environ = _run( async_asgi.translate_request( { @@ -373,10 +362,10 @@ def test_translate_request(self): assert body == b'hello world' def test_translate_request_no_query_string(self): - receive = AsyncMock( + receive = mock.AsyncMock( return_value={'type': 'http.request', 'body': b'hello world'} ) - send = AsyncMock() + send = mock.AsyncMock() environ = _run( async_asgi.translate_request( { @@ -415,7 +404,7 @@ def test_translate_request_no_query_string(self): assert body == b'hello world' def test_translate_request_with_large_body(self): - receive = AsyncMock( + receive = mock.AsyncMock( side_effect=[ {'type': 'http.request', 'body': b'hello ', 'more_body': True}, {'type': 'http.request', 'body': b'world', 'more_body': True}, @@ -423,7 +412,7 @@ def test_translate_request_with_large_body(self): {'type': 'http.request', 'body': b'!!!'}, ] ) - send = AsyncMock() + send = mock.AsyncMock() environ = _run( async_asgi.translate_request( { @@ -463,8 +452,8 @@ def test_translate_request_with_large_body(self): assert body == b'hello world' def test_translate_websocket_request(self): - receive = AsyncMock(return_value={'type': 'websocket.connect'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'websocket.connect'}) + send = mock.AsyncMock() _run( async_asgi.translate_request( { @@ -483,11 +472,11 @@ def test_translate_websocket_request(self): send, ) ) - send.mock.assert_not_called() + send.assert_not_awaited() def test_translate_unknown_request(self): - receive = AsyncMock(return_value={'type': 'http.foo'}) - send = AsyncMock() + receive = mock.AsyncMock(return_value={'type': 'http.foo'}) + send = mock.AsyncMock() environ = _run( async_asgi.translate_request( {'type': 'http', 'path': '/foo/bar', 'query_string': b'baz=1'}, @@ -498,26 +487,27 @@ def test_translate_unknown_request(self): assert environ == {} def test_make_response(self): - environ = {'asgi.send': AsyncMock(), 'asgi.scope': {'type': 'http'}} + environ = {'asgi.send': mock.AsyncMock(), + 'asgi.scope': {'type': 'http'}} _run( async_asgi.make_response( '202 ACCEPTED', [('foo', 'bar')], b'payload', environ ) ) - environ['asgi.send'].mock.assert_any_call( + environ['asgi.send'].assert_any_await( { 'type': 'http.response.start', 'status': 202, 'headers': [(b'foo', b'bar')], } ) - environ['asgi.send'].mock.assert_any_call( + environ['asgi.send'].assert_any_await( {'type': 'http.response.body', 'body': b'payload'} ) def test_make_response_websocket_accept(self): environ = { - 'asgi.send': AsyncMock(), + 'asgi.send': mock.AsyncMock(), 'asgi.scope': {'type': 'websocket'}, } _run( @@ -525,13 +515,13 @@ def test_make_response_websocket_accept(self): '200 OK', [('foo', 'bar')], b'payload', environ ) ) - environ['asgi.send'].mock.assert_called_with( + environ['asgi.send'].assert_awaited_with( {'type': 'websocket.accept', 'headers': [(b'foo', b'bar')]} ) def test_make_response_websocket_reject(self): environ = { - 'asgi.send': AsyncMock(), + 'asgi.send': mock.AsyncMock(), 'asgi.scope': {'type': 'websocket'}, } _run( @@ -539,13 +529,13 @@ def test_make_response_websocket_reject(self): '401 UNAUTHORIZED', [('foo', 'bar')], b'payload', environ ) ) - environ['asgi.send'].mock.assert_called_with( + environ['asgi.send'].assert_awaited_with( {'type': 'websocket.close', 'reason': 'payload'} ) def test_make_response_websocket_reject_no_payload(self): environ = { - 'asgi.send': AsyncMock(), + 'asgi.send': mock.AsyncMock(), 'asgi.scope': {'type': 'websocket'}, } _run( @@ -553,7 +543,7 @@ def test_make_response_websocket_reject_no_payload(self): '401 UNAUTHORIZED', [('foo', 'bar')], None, environ ) ) - environ['asgi.send'].mock.assert_called_with( + environ['asgi.send'].assert_awaited_with( {'type': 'websocket.close'} ) @@ -571,15 +561,15 @@ async def __call__(self, scope, receive, send): return assert False, 'No route found' - other_app = AsyncMock() + other_app = mock.AsyncMock() mock_server = mock.MagicMock() - mock_server.handle_request = AsyncMock() + mock_server.handle_request = mock.AsyncMock() eio_app = async_asgi.ASGIApp(mock_server, engineio_path=None) root_app = ASGIDispatcher({'/foo': other_app, '/eio': eio_app}) scope = {'type': 'http', 'path': '/foo/bar'} _run(root_app(scope, 'receive', 'send')) - other_app.mock.assert_called_once_with(scope, 'receive', 'send') + other_app.assert_awaited_once_with(scope, 'receive', 'send') scope = {'type': 'http', 'path': '/eio/'} _run(root_app(scope, 'receive', 'send')) - eio_app.engineio_server.handle_request.mock.assert_called_once_with( + eio_app.engineio_server.handle_request.assert_awaited_once_with( scope, 'receive', 'send') diff --git a/tests/async/test_client.py b/tests/async/test_client.py index 2271a7ba..299a82c6 100644 --- a/tests/async/test_client.py +++ b/tests/async/test_client.py @@ -15,17 +15,6 @@ from engineio import payload -def AsyncMock(*args, **kwargs): - """Return a mock asynchronous function.""" - m = mock.MagicMock(*args, **kwargs) - - async def mock_coro(*args, **kwargs): - return m(*args, **kwargs) - - mock_coro.mock = m - return mock_coro - - def _run(coro): """Run the given coroutine.""" return asyncio.get_event_loop().run_until_complete(coro) @@ -49,63 +38,63 @@ def test_invalid_transports(self): def test_some_invalid_transports(self): c = async_client.AsyncClient() - c._connect_websocket = AsyncMock() + c._connect_websocket = mock.AsyncMock() _run(c.connect('http://foo', transports=['foo', 'websocket', 'bar'])) assert c.transports == ['websocket'] def test_connect_polling(self): c = async_client.AsyncClient() - c._connect_polling = AsyncMock(return_value='foo') + c._connect_polling = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo')) == 'foo' - c._connect_polling.mock.assert_called_once_with( + c._connect_polling.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) c = async_client.AsyncClient() - c._connect_polling = AsyncMock(return_value='foo') + c._connect_polling = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo', transports=['polling'])) == 'foo' - c._connect_polling.mock.assert_called_once_with( + c._connect_polling.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) c = async_client.AsyncClient() - c._connect_polling = AsyncMock(return_value='foo') + c._connect_polling = mock.AsyncMock(return_value='foo') assert ( _run(c.connect('http://foo', transports=['polling', 'websocket'])) == 'foo' ) - c._connect_polling.mock.assert_called_once_with( + c._connect_polling.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) def test_connect_websocket(self): c = async_client.AsyncClient() - c._connect_websocket = AsyncMock(return_value='foo') + c._connect_websocket = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo', transports=['websocket'])) == 'foo' - c._connect_websocket.mock.assert_called_once_with( + c._connect_websocket.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) c = async_client.AsyncClient() - c._connect_websocket = AsyncMock(return_value='foo') + c._connect_websocket = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo', transports='websocket')) == 'foo' - c._connect_websocket.mock.assert_called_once_with( + c._connect_websocket.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) def test_connect_query_string(self): c = async_client.AsyncClient() - c._connect_polling = AsyncMock(return_value='foo') + c._connect_polling = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo?bar=baz')) == 'foo' - c._connect_polling.mock.assert_called_once_with( + c._connect_polling.assert_awaited_once_with( 'http://foo?bar=baz', {}, 'engine.io' ) def test_connect_custom_headers(self): c = async_client.AsyncClient() - c._connect_polling = AsyncMock(return_value='foo') + c._connect_polling = mock.AsyncMock(return_value='foo') assert _run(c.connect('http://foo', headers={'Foo': 'Bar'})) == 'foo' - c._connect_polling.mock.assert_called_once_with( + c._connect_polling.assert_awaited_once_with( 'http://foo', {'Foo': 'Bar'}, 'engine.io' ) @@ -160,16 +149,16 @@ def test_disconnect_polling(self): c.state = 'connected' c.current_transport = 'polling' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c.queue.join = AsyncMock() - c.read_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c.queue.join = mock.AsyncMock() + c.read_loop_task = mock.AsyncMock()() c.ws = mock.MagicMock() - c.ws.close = AsyncMock() - c._trigger_event = AsyncMock() + c.ws.close = mock.AsyncMock() + c._trigger_event = mock.AsyncMock() _run(c.disconnect()) - c.ws.close.mock.assert_not_called() + c.ws.close.assert_not_awaited() assert c not in base_client.connected_clients - c._trigger_event.mock.assert_called_once_with( + c._trigger_event.assert_awaited_once_with( 'disconnect', run_async=False ) @@ -179,16 +168,16 @@ def test_disconnect_websocket(self): c.state = 'connected' c.current_transport = 'websocket' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c.queue.join = AsyncMock() - c.read_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c.queue.join = mock.AsyncMock() + c.read_loop_task = mock.AsyncMock()() c.ws = mock.MagicMock() - c.ws.close = AsyncMock() - c._trigger_event = AsyncMock() + c.ws.close = mock.AsyncMock() + c._trigger_event = mock.AsyncMock() _run(c.disconnect()) - c.ws.close.mock.assert_called_once_with() + c.ws.close.assert_awaited_once_with() assert c not in base_client.connected_clients - c._trigger_event.mock.assert_called_once_with( + c._trigger_event.assert_awaited_once_with( 'disconnect', run_async=False ) @@ -198,14 +187,14 @@ def test_disconnect_polling_abort(self): c.state = 'connected' c.current_transport = 'polling' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c.queue.join = AsyncMock() - c.read_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c.queue.join = mock.AsyncMock() + c.read_loop_task = mock.AsyncMock()() c.ws = mock.MagicMock() - c.ws.close = AsyncMock() + c.ws.close = mock.AsyncMock() _run(c.disconnect(abort=True)) - c.queue.join.mock.assert_not_called() - c.ws.close.mock.assert_not_called() + c.queue.join.assert_not_awaited() + c.ws.close.assert_not_awaited() assert c not in base_client.connected_clients def test_disconnect_websocket_abort(self): @@ -214,14 +203,14 @@ def test_disconnect_websocket_abort(self): c.state = 'connected' c.current_transport = 'websocket' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c.queue.join = AsyncMock() - c.read_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c.queue.join = mock.AsyncMock() + c.read_loop_task = mock.AsyncMock()() c.ws = mock.MagicMock() - c.ws.close = AsyncMock() + c.ws.close = mock.AsyncMock() _run(c.disconnect(abort=True)) - c.queue.join.mock.assert_not_called() - c.ws.mock.assert_not_called() + c.queue.join.assert_not_awaited() + c.ws.assert_not_called() assert c not in base_client.connected_clients def test_background_tasks(self): @@ -257,10 +246,10 @@ def test_create_event(self): @mock.patch('engineio.client.time.time', return_value=123.456) def test_polling_connection_failed(self, _time): c = async_client.AsyncClient() - c._send_request = AsyncMock(return_value=None) + c._send_request = mock.AsyncMock(return_value=None) with pytest.raises(exceptions.ConnectionError): _run(c.connect('http://foo', headers={'Foo': 'Bar'})) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'GET', 'http://foo/engine.io/?transport=polling&EIO=4&t=123.456', headers={'Foo': 'Bar'}, @@ -269,9 +258,9 @@ def test_polling_connection_failed(self, _time): def test_polling_connection_404(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 404 - c._send_request.mock.return_value.json = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 404 + c._send_request.return_value.json = mock.AsyncMock( return_value={'foo': 'bar'} ) try: @@ -285,9 +274,9 @@ def test_polling_connection_404(self): def test_polling_connection_404_no_json(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 404 - c._send_request.mock.return_value.json = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 404 + c._send_request.return_value.json = mock.AsyncMock( side_effect=aiohttp.ContentTypeError('foo', 'bar') ) try: @@ -301,17 +290,17 @@ def test_polling_connection_404_no_json(self): def test_polling_connection_invalid_packet(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock(return_value=b'foo') + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock(return_value=b'foo') with pytest.raises(exceptions.ConnectionError): _run(c.connect('http://foo')) def test_polling_connection_no_open_packet(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -331,9 +320,9 @@ def test_polling_connection_no_open_packet(self): def test_polling_connection_successful(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -348,17 +337,17 @@ def test_polling_connection_successful(self): ] ).encode().encode('utf-8') ) - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() - on_connect = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() + on_connect = mock.AsyncMock() c.on('connect', on_connect) _run(c.connect('http://foo')) - c._read_loop_polling.mock.assert_called_once_with() - c._read_loop_websocket.mock.assert_not_called() - c._write_loop.mock.assert_called_once_with() - on_connect.mock.assert_called_once_with() + c._read_loop_polling.assert_awaited_once_with() + c._read_loop_websocket.assert_not_awaited() + c._write_loop.assert_awaited_once_with() + on_connect.assert_awaited_once_with() assert c in base_client.connected_clients assert ( c.base_url @@ -372,9 +361,9 @@ def test_polling_connection_successful(self): def test_polling_https_noverify_connection_successful(self): c = async_client.AsyncClient(ssl_verify=False) - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -389,17 +378,17 @@ def test_polling_https_noverify_connection_successful(self): ] ).encode().encode('utf-8') ) - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() - on_connect = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() + on_connect = mock.AsyncMock() c.on('connect', on_connect) _run(c.connect('https://foo')) - c._read_loop_polling.mock.assert_called_once_with() - c._read_loop_websocket.mock.assert_not_called() - c._write_loop.mock.assert_called_once_with() - on_connect.mock.assert_called_once_with() + c._read_loop_polling.assert_awaited_once_with() + c._read_loop_websocket.assert_not_awaited() + c._write_loop.assert_awaited_once_with() + on_connect.assert_awaited_once_with() assert c in base_client.connected_clients assert ( c.base_url @@ -413,9 +402,9 @@ def test_polling_https_noverify_connection_successful(self): def test_polling_connection_with_more_packets(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -431,24 +420,24 @@ def test_polling_connection_with_more_packets(self): ] ).encode().encode('utf-8') ) - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() - c._receive_packet = AsyncMock() - on_connect = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() + c._receive_packet = mock.AsyncMock() + on_connect = mock.AsyncMock() c.on('connect', on_connect) _run(c.connect('http://foo')) - assert c._receive_packet.mock.call_count == 1 + assert c._receive_packet.await_count == 1 assert ( - c._receive_packet.mock.call_args_list[0][0][0].packet_type + c._receive_packet.await_args_list[0][0][0].packet_type == packet.NOOP ) def test_polling_connection_upgraded(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -463,12 +452,12 @@ def test_polling_connection_upgraded(self): ] ).encode().encode('utf-8') ) - c._connect_websocket = AsyncMock(return_value=True) + c._connect_websocket = mock.AsyncMock(return_value=True) on_connect = mock.MagicMock() c.on('connect', on_connect) _run(c.connect('http://foo')) - c._connect_websocket.mock.assert_called_once_with( + c._connect_websocket.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) on_connect.assert_called_once_with() @@ -484,9 +473,9 @@ def test_polling_connection_upgraded(self): def test_polling_connection_not_upgraded(self): c = async_client.AsyncClient() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock( + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet( @@ -501,20 +490,20 @@ def test_polling_connection_not_upgraded(self): ] ).encode().encode('utf-8') ) - c._connect_websocket = AsyncMock(return_value=False) - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._connect_websocket = mock.AsyncMock(return_value=False) + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run(c.connect('http://foo')) - c._connect_websocket.mock.assert_called_once_with( + c._connect_websocket.assert_awaited_once_with( 'http://foo', {}, 'engine.io' ) - c._read_loop_polling.mock.assert_called_once_with() - c._read_loop_websocket.mock.assert_not_called() - c._write_loop.mock.assert_called_once_with() + c._read_loop_polling.assert_awaited_once_with() + c._read_loop_websocket.assert_not_awaited() + c._write_loop.assert_awaited_once_with() on_connect.assert_called_once_with() assert c in base_client.connected_clients @@ -522,7 +511,7 @@ def test_polling_connection_not_upgraded(self): def test_websocket_connection_failed(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock( + c.http.ws_connect = mock.AsyncMock( side_effect=[aiohttp.client_exceptions.ServerConnectionError()] ) with pytest.raises(exceptions.ConnectionError): @@ -533,7 +522,7 @@ def test_websocket_connection_failed(self, _time): headers={'Foo': 'Bar'}, ) ) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={'Foo': 'Bar'}, timeout=5 @@ -546,7 +535,7 @@ def test_websocket_connection_extra(self, _time): 'timeout': 10 }) c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock( + c.http.ws_connect = mock.AsyncMock( side_effect=[aiohttp.client_exceptions.ServerConnectionError()] ) with pytest.raises(exceptions.ConnectionError): @@ -557,7 +546,7 @@ def test_websocket_connection_extra(self, _time): headers={'Foo': 'Bar'}, ) ) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={'Foo': 'Bar', 'Baz': 'Qux'}, timeout=10, @@ -567,12 +556,12 @@ def test_websocket_connection_extra(self, _time): def test_websocket_upgrade_failed(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock( + c.http.ws_connect = mock.AsyncMock( side_effect=[aiohttp.client_exceptions.ServerConnectionError()] ) c.sid = '123' assert not _run(c.connect('http://foo', transports=['websocket'])) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&sid=123&t=123.456', headers={}, timeout=5, @@ -581,10 +570,10 @@ def test_websocket_upgrade_failed(self, _time): def test_websocket_connection_no_open_packet(self): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.CLOSE ).encode() with pytest.raises(exceptions.ConnectionError): @@ -594,10 +583,10 @@ def test_websocket_connection_no_open_packet(self): def test_websocket_connection_successful(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -606,16 +595,16 @@ def test_websocket_connection_successful(self, _time): 'pingTimeout': 2000, }, ).encode() - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run(c.connect('ws://foo', transports=['websocket'])) - c._read_loop_polling.mock.assert_not_called() - c._read_loop_websocket.mock.assert_called_once_with() - c._write_loop.mock.assert_called_once_with() + c._read_loop_polling.assert_not_awaited() + c._read_loop_websocket.assert_awaited_once_with() + c._write_loop.assert_awaited_once_with() on_connect.assert_called_once_with() assert c in base_client.connected_clients assert c.base_url == 'ws://foo/engine.io/?transport=websocket&EIO=4' @@ -625,7 +614,7 @@ def test_websocket_connection_successful(self, _time): assert c.upgrades == [] assert c.transport() == 'websocket' assert c.ws == ws - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={}, timeout=5, @@ -635,10 +624,10 @@ def test_websocket_connection_successful(self, _time): def test_websocket_https_noverify_connection_successful(self, _time): c = async_client.AsyncClient(ssl_verify=False) c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -647,16 +636,16 @@ def test_websocket_https_noverify_connection_successful(self, _time): 'pingTimeout': 2000, }, ).encode() - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run(c.connect('wss://foo', transports=['websocket'])) - c._read_loop_polling.mock.assert_not_called() - c._read_loop_websocket.mock.assert_called_once_with() - c._write_loop.mock.assert_called_once_with() + c._read_loop_polling.assert_not_awaited() + c._read_loop_websocket.assert_awaited_once_with() + c._write_loop.assert_awaited_once_with() on_connect.assert_called_once_with() assert c in base_client.connected_clients assert c.base_url == 'wss://foo/engine.io/?transport=websocket&EIO=4' @@ -666,7 +655,7 @@ def test_websocket_https_noverify_connection_successful(self, _time): assert c.upgrades == [] assert c.transport() == 'websocket' assert c.ws == ws - _, kwargs = c.http.ws_connect.mock.call_args + _, kwargs = c.http.ws_connect.await_args assert 'ssl' in kwargs assert isinstance(kwargs['ssl'], ssl.SSLContext) assert kwargs['ssl'].verify_mode == ssl.CERT_NONE @@ -675,10 +664,10 @@ def test_websocket_https_noverify_connection_successful(self, _time): def test_websocket_connection_with_cookies(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -692,13 +681,13 @@ def test_websocket_connection_with_cookies(self, _time): c.http._cookie_jar[0].value = 'value' c.http._cookie_jar[1].key = 'key2' c.http._cookie_jar[1].value = 'value2' - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run(c.connect('ws://foo', transports=['websocket'])) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={}, timeout=5, @@ -708,10 +697,10 @@ def test_websocket_connection_with_cookies(self, _time): def test_websocket_connection_with_cookie_header(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -721,9 +710,9 @@ def test_websocket_connection_with_cookie_header(self, _time): }, ).encode() c.http._cookie_jar = [] - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run( @@ -733,7 +722,7 @@ def test_websocket_connection_with_cookie_header(self, _time): transports=['websocket'], ) ) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={}, timeout=5, @@ -746,10 +735,10 @@ def test_websocket_connection_with_cookie_header(self, _time): def test_websocket_connection_with_cookies_and_headers(self, _time): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -763,9 +752,9 @@ def test_websocket_connection_with_cookies_and_headers(self, _time): c.http._cookie_jar[0].value = 'value' c.http._cookie_jar[1].key = 'key2' c.http._cookie_jar[1].value = 'value2' - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) _run( @@ -775,7 +764,7 @@ def test_websocket_connection_with_cookies_and_headers(self, _time): transports=['websocket'], ) ) - c.http.ws_connect.mock.assert_called_once_with( + c.http.ws_connect.assert_awaited_once_with( 'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456', headers={'Foo': 'Bar'}, timeout=5, @@ -787,10 +776,10 @@ def test_websocket_connection_with_cookies_and_headers(self, _time): def test_websocket_upgrade_no_pong(self): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.OPEN, { 'sid': '123', @@ -799,54 +788,54 @@ def test_websocket_upgrade_no_pong(self): 'pingTimeout': 2000, }, ).encode() - ws.send_str = AsyncMock() + ws.send_str = mock.AsyncMock() c.sid = '123' c.current_transport = 'polling' - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) assert not _run(c.connect('ws://foo', transports=['websocket'])) - c._read_loop_polling.mock.assert_not_called() - c._read_loop_websocket.mock.assert_not_called() - c._write_loop.mock.assert_not_called() + c._read_loop_polling.assert_not_awaited() + c._read_loop_websocket.assert_not_awaited() + c._write_loop.assert_not_awaited() on_connect.assert_not_called() assert c.transport() == 'polling' - ws.send_str.mock.assert_called_once_with('2probe') + ws.send_str.assert_awaited_once_with('2probe') def test_websocket_upgrade_successful(self): c = async_client.AsyncClient() c.http = mock.MagicMock(closed=False) - c.http.ws_connect = AsyncMock() - ws = c.http.ws_connect.mock.return_value - ws.receive = AsyncMock() - ws.receive.mock.return_value.data = packet.Packet( + c.http.ws_connect = mock.AsyncMock() + ws = c.http.ws_connect.return_value + ws.receive = mock.AsyncMock() + ws.receive.return_value.data = packet.Packet( packet.PONG, 'probe' ).encode() - ws.send_str = AsyncMock() + ws.send_str = mock.AsyncMock() c.sid = '123' c.base_url = 'http://foo' c.current_transport = 'polling' - c._read_loop_polling = AsyncMock() - c._read_loop_websocket = AsyncMock() - c._write_loop = AsyncMock() + c._read_loop_polling = mock.AsyncMock() + c._read_loop_websocket = mock.AsyncMock() + c._write_loop = mock.AsyncMock() on_connect = mock.MagicMock() c.on('connect', on_connect) assert _run(c.connect('ws://foo', transports=['websocket'])) - c._read_loop_polling.mock.assert_not_called() - c._read_loop_websocket.mock.assert_called_once_with() - c._write_loop.mock.assert_called_once_with() + c._read_loop_polling.assert_not_awaited() + c._read_loop_websocket.assert_awaited_once_with() + c._write_loop.assert_awaited_once_with() on_connect.assert_not_called() # was called by polling assert c not in base_client.connected_clients # was added by polling assert c.base_url == 'http://foo' # not changed assert c.sid == '123' # not changed assert c.transport() == 'websocket' assert c.ws == ws - assert ws.send_str.mock.call_args_list[0] == (('2probe',),) # ping - assert ws.send_str.mock.call_args_list[1] == (('5',),) # upgrade + assert ws.send_str.await_args_list[0] == (('2probe',),) # ping + assert ws.send_str.await_args_list[1] == (('5',),) # upgrade def test_receive_unknown_packet(self): c = async_client.AsyncClient() @@ -860,23 +849,23 @@ def test_receive_noop_packet(self): def test_receive_ping_packet(self): c = async_client.AsyncClient() - c._send_packet = AsyncMock() + c._send_packet = mock.AsyncMock() _run(c._receive_packet(packet.Packet(packet.PING))) - assert c._send_packet.mock.call_args_list[0][0][0].encode() == '3' + assert c._send_packet.await_args_list[0][0][0].encode() == '3' def test_receive_message_packet(self): c = async_client.AsyncClient() - c._trigger_event = AsyncMock() + c._trigger_event = mock.AsyncMock() _run(c._receive_packet(packet.Packet(packet.MESSAGE, {'foo': 'bar'}))) - c._trigger_event.mock.assert_called_once_with( + c._trigger_event.assert_awaited_once_with( 'message', {'foo': 'bar'}, run_async=True ) def test_receive_close_packet(self): c = async_client.AsyncClient() - c.disconnect = AsyncMock() + c.disconnect = mock.AsyncMock() _run(c._receive_packet(packet.Packet(packet.CLOSE))) - c.disconnect.mock.assert_called_once_with(abort=True) + c.disconnect.assert_awaited_once_with(abort=True) def test_send_packet_disconnected(self): c = async_client.AsyncClient() @@ -1007,10 +996,10 @@ def test_trigger_unknown_event(self): def test_read_loop_polling_disconnected(self): c = async_client.AsyncClient() c.state = 'disconnected' - c._trigger_event = AsyncMock() - c.write_loop_task = AsyncMock()() + c._trigger_event = mock.AsyncMock() + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_polling()) - c._trigger_event.mock.assert_not_called() + c._trigger_event.assert_not_awaited() # should not block @mock.patch('engineio.client.time.time', return_value=123.456) @@ -1021,17 +1010,17 @@ def test_read_loop_polling_no_response(self, _time): c.state = 'connected' c.base_url = 'http://foo' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c._send_request = AsyncMock(return_value=None) - c._trigger_event = AsyncMock() - c.write_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c._send_request = mock.AsyncMock(return_value=None) + c._trigger_event = mock.AsyncMock() + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_polling()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) - c._send_request.mock.assert_called_once_with( + c.queue.put.assert_awaited_once_with(None) + c._send_request.assert_awaited_once_with( 'GET', 'http://foo&t=123.456', timeout=30 ) - c._trigger_event.mock.assert_called_once_with( + c._trigger_event.assert_awaited_once_with( 'disconnect', run_async=False ) @@ -1043,14 +1032,14 @@ def test_read_loop_polling_bad_status(self, _time): c.state = 'connected' c.base_url = 'http://foo' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 400 - c.write_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 400 + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_polling()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) - c._send_request.mock.assert_called_once_with( + c.queue.put.assert_awaited_once_with(None) + c._send_request.assert_awaited_once_with( 'GET', 'http://foo&t=123.456', timeout=30 ) @@ -1062,15 +1051,15 @@ def test_read_loop_polling_bad_packet(self, _time): c.state = 'connected' c.base_url = 'http://foo' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 - c._send_request.mock.return_value.read = AsyncMock(return_value=b'foo') - c.write_loop_task = AsyncMock()() + c.queue.put = mock.AsyncMock() + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 + c._send_request.return_value.read = mock.AsyncMock(return_value=b'foo') + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_polling()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) - c._send_request.mock.assert_called_once_with( + c.queue.put.assert_awaited_once_with(None) + c._send_request.assert_awaited_once_with( 'GET', 'http://foo&t=123.456', timeout=65 ) @@ -1081,12 +1070,12 @@ def test_read_loop_polling(self): c.state = 'connected' c.base_url = 'http://foo' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() - c._send_request = AsyncMock() - c._send_request.mock.side_effect = [ + c.queue.put = mock.AsyncMock() + c._send_request = mock.AsyncMock() + c._send_request.side_effect = [ mock.MagicMock( status=200, - read=AsyncMock( + read=mock.AsyncMock( return_value=payload.Payload( packets=[ packet.Packet(packet.PING), @@ -1097,20 +1086,20 @@ def test_read_loop_polling(self): ), None, ] - c.write_loop_task = AsyncMock()() - c._receive_packet = AsyncMock() + c.write_loop_task = mock.AsyncMock()() + c._receive_packet = mock.AsyncMock() _run(c._read_loop_polling()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) - assert c._send_request.mock.call_count == 2 - assert c._receive_packet.mock.call_count == 2 - assert c._receive_packet.mock.call_args_list[0][0][0].encode() == '2' - assert c._receive_packet.mock.call_args_list[1][0][0].encode() == '6' + c.queue.put.assert_awaited_once_with(None) + assert c._send_request.await_count == 2 + assert c._receive_packet.await_count == 2 + assert c._receive_packet.await_args_list[0][0][0].encode() == '2' + assert c._receive_packet.await_args_list[1][0][0].encode() == '6' def test_read_loop_websocket_disconnected(self): c = async_client.AsyncClient() c.state = 'disconnected' - c.write_loop_task = AsyncMock()() + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_websocket()) # should not block @@ -1121,13 +1110,13 @@ def test_read_loop_websocket_timeout(self): c.base_url = 'ws://foo' c.state = 'connected' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() + c.queue.put = mock.AsyncMock() c.ws = mock.MagicMock() - c.ws.receive = AsyncMock(side_effect=asyncio.TimeoutError()) - c.write_loop_task = AsyncMock()() + c.ws.receive = mock.AsyncMock(side_effect=asyncio.TimeoutError()) + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_websocket()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) + c.queue.put.assert_awaited_once_with(None) def test_read_loop_websocket_no_response(self): c = async_client.AsyncClient() @@ -1136,15 +1125,15 @@ def test_read_loop_websocket_no_response(self): c.base_url = 'ws://foo' c.state = 'connected' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() + c.queue.put = mock.AsyncMock() c.ws = mock.MagicMock() - c.ws.receive = AsyncMock( + c.ws.receive = mock.AsyncMock( side_effect=aiohttp.client_exceptions.ServerDisconnectedError() ) - c.write_loop_task = AsyncMock()() + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_websocket()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) + c.queue.put.assert_awaited_once_with(None) def test_read_loop_websocket_unexpected_error(self): c = async_client.AsyncClient() @@ -1153,13 +1142,13 @@ def test_read_loop_websocket_unexpected_error(self): c.base_url = 'ws://foo' c.state = 'connected' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() + c.queue.put = mock.AsyncMock() c.ws = mock.MagicMock() - c.ws.receive = AsyncMock(side_effect=ValueError) - c.write_loop_task = AsyncMock()() + c.ws.receive = mock.AsyncMock(side_effect=ValueError) + c.write_loop_task = mock.AsyncMock()() _run(c._read_loop_websocket()) assert c.state == 'disconnected' - c.queue.put.mock.assert_called_once_with(None) + c.queue.put.assert_awaited_once_with(None) def test_read_loop_websocket(self): c = async_client.AsyncClient() @@ -1168,20 +1157,20 @@ def test_read_loop_websocket(self): c.base_url = 'ws://foo' c.state = 'connected' c.queue = mock.MagicMock() - c.queue.put = AsyncMock() + c.queue.put = mock.AsyncMock() c.ws = mock.MagicMock() - c.ws.receive = AsyncMock( + c.ws.receive = mock.AsyncMock( side_effect=[ mock.MagicMock(data=packet.Packet(packet.PING).encode()), ValueError, ] ) - c.write_loop_task = AsyncMock()() - c._receive_packet = AsyncMock() + c.write_loop_task = mock.AsyncMock()() + c._receive_packet = mock.AsyncMock() _run(c._read_loop_websocket()) assert c.state == 'disconnected' - assert c._receive_packet.mock.call_args_list[0][0][0].encode() == '2' - c.queue.put.mock.assert_called_once_with(None) + assert c._receive_packet.await_args_list[0][0][0].encode() == '2' + c.queue.put.assert_awaited_once_with(None) def test_write_loop_disconnected(self): c = async_client.AsyncClient() @@ -1195,10 +1184,10 @@ def test_write_loop_no_packets(self): c.ping_interval = 1 c.ping_timeout = 2 c.queue = mock.MagicMock() - c.queue.get = AsyncMock(return_value=None) + c.queue.get = mock.AsyncMock(return_value=None) _run(c._write_loop()) c.queue.task_done.assert_called_once_with() - c.queue.get.mock.assert_called_once_with() + c.queue.get.assert_awaited_once_with() def test_write_loop_empty_queue(self): c = async_client.AsyncClient() @@ -1207,9 +1196,9 @@ def test_write_loop_empty_queue(self): c.ping_timeout = 2 c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock(side_effect=RuntimeError) + c.queue.get = mock.AsyncMock(side_effect=RuntimeError) _run(c._write_loop()) - c.queue.get.mock.assert_called_once_with() + c.queue.get.assert_awaited_once_with() def test_write_loop_polling_one_packet(self): c = async_client.AsyncClient() @@ -1220,21 +1209,21 @@ def test_write_loop_polling_one_packet(self): c.current_transport = 'polling' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, ] ) c.queue.get_nowait = mock.MagicMock(side_effect=RuntimeError) - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 _run(c._write_loop()) assert c.queue.task_done.call_count == 1 p = payload.Payload( packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})] ) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'POST', 'http://foo', body=p.encode(), @@ -1251,7 +1240,7 @@ def test_write_loop_polling_three_packets(self): c.current_transport = 'polling' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, @@ -1264,8 +1253,8 @@ def test_write_loop_polling_three_packets(self): RuntimeError, ] ) - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 _run(c._write_loop()) assert c.queue.task_done.call_count == 3 p = payload.Payload( @@ -1275,7 +1264,7 @@ def test_write_loop_polling_three_packets(self): packet.Packet(packet.NOOP), ] ) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'POST', 'http://foo', body=p.encode(), @@ -1292,7 +1281,7 @@ def test_write_loop_polling_two_packets_done(self): c.current_transport = 'polling' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, @@ -1301,8 +1290,8 @@ def test_write_loop_polling_two_packets_done(self): c.queue.get_nowait = mock.MagicMock( side_effect=[packet.Packet(packet.PING), None] ) - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 200 + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 200 _run(c._write_loop()) assert c.queue.task_done.call_count == 3 p = payload.Payload( @@ -1311,7 +1300,7 @@ def test_write_loop_polling_two_packets_done(self): packet.Packet(packet.PING), ] ) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'POST', 'http://foo', body=p.encode(), @@ -1329,17 +1318,17 @@ def test_write_loop_polling_bad_connection(self): c.current_transport = 'polling' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})] ) c.queue.get_nowait = mock.MagicMock(side_effect=[RuntimeError]) - c._send_request = AsyncMock(return_value=None) + c._send_request = mock.AsyncMock(return_value=None) _run(c._write_loop()) assert c.queue.task_done.call_count == 1 p = payload.Payload( packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})] ) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'POST', 'http://foo', body=p.encode(), @@ -1357,18 +1346,18 @@ def test_write_loop_polling_bad_status(self): c.current_transport = 'polling' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})] ) c.queue.get_nowait = mock.MagicMock(side_effect=[RuntimeError]) - c._send_request = AsyncMock() - c._send_request.mock.return_value.status = 500 + c._send_request = mock.AsyncMock() + c._send_request.return_value.status = 500 _run(c._write_loop()) assert c.queue.task_done.call_count == 1 p = payload.Payload( packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})] ) - c._send_request.mock.assert_called_once_with( + c._send_request.assert_awaited_once_with( 'POST', 'http://foo', body=p.encode(), @@ -1386,7 +1375,7 @@ def test_write_loop_websocket_one_packet(self): c.current_transport = 'websocket' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, @@ -1394,11 +1383,11 @@ def test_write_loop_websocket_one_packet(self): ) c.queue.get_nowait = mock.MagicMock(side_effect=[RuntimeError]) c.ws = mock.MagicMock() - c.ws.send_str = AsyncMock() + c.ws.send_str = mock.AsyncMock() _run(c._write_loop()) assert c.queue.task_done.call_count == 1 - assert c.ws.send_str.mock.call_count == 1 - c.ws.send_str.mock.assert_called_once_with('4{"foo":"bar"}') + assert c.ws.send_str.await_count == 1 + c.ws.send_str.assert_awaited_once_with('4{"foo":"bar"}') def test_write_loop_websocket_three_packets(self): c = async_client.AsyncClient() @@ -1408,7 +1397,7 @@ def test_write_loop_websocket_three_packets(self): c.current_transport = 'websocket' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, @@ -1422,13 +1411,13 @@ def test_write_loop_websocket_three_packets(self): ] ) c.ws = mock.MagicMock() - c.ws.send_str = AsyncMock() + c.ws.send_str = mock.AsyncMock() _run(c._write_loop()) assert c.queue.task_done.call_count == 3 - assert c.ws.send_str.mock.call_count == 3 - assert c.ws.send_str.mock.call_args_list[0][0][0] == '4{"foo":"bar"}' - assert c.ws.send_str.mock.call_args_list[1][0][0] == '2' - assert c.ws.send_str.mock.call_args_list[2][0][0] == '6' + assert c.ws.send_str.await_count == 3 + assert c.ws.send_str.await_args_list[0][0][0] == '4{"foo":"bar"}' + assert c.ws.send_str.await_args_list[1][0][0] == '2' + assert c.ws.send_str.await_args_list[2][0][0] == '6' def test_write_loop_websocket_one_packet_binary(self): c = async_client.AsyncClient() @@ -1438,16 +1427,16 @@ def test_write_loop_websocket_one_packet_binary(self): c.current_transport = 'websocket' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[packet.Packet(packet.MESSAGE, b'foo'), RuntimeError] ) c.queue.get_nowait = mock.MagicMock(side_effect=[RuntimeError]) c.ws = mock.MagicMock() - c.ws.send_bytes = AsyncMock() + c.ws.send_bytes = mock.AsyncMock() _run(c._write_loop()) assert c.queue.task_done.call_count == 1 - assert c.ws.send_bytes.mock.call_count == 1 - c.ws.send_bytes.mock.assert_called_once_with(b'foo') + assert c.ws.send_bytes.await_count == 1 + c.ws.send_bytes.assert_awaited_once_with(b'foo') def test_write_loop_websocket_bad_connection(self): c = async_client.AsyncClient() @@ -1457,7 +1446,7 @@ def test_write_loop_websocket_bad_connection(self): c.current_transport = 'websocket' c.queue = mock.MagicMock() c.queue.Empty = RuntimeError - c.queue.get = AsyncMock( + c.queue.get = mock.AsyncMock( side_effect=[ packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError, @@ -1465,7 +1454,7 @@ def test_write_loop_websocket_bad_connection(self): ) c.queue.get_nowait = mock.MagicMock(side_effect=[RuntimeError]) c.ws = mock.MagicMock() - c.ws.send_str = AsyncMock( + c.ws.send_str = mock.AsyncMock( side_effect=aiohttp.client_exceptions.ServerDisconnectedError() ) _run(c._write_loop()) diff --git a/tests/async/test_server.py b/tests/async/test_server.py index 39746245..95e47a5b 100644 --- a/tests/async/test_server.py +++ b/tests/async/test_server.py @@ -15,17 +15,6 @@ from engineio import payload -def AsyncMock(*args, **kwargs): - """Return a mock asynchronous function.""" - m = mock.MagicMock(*args, **kwargs) - - async def mock_coro(*args, **kwargs): - return m(*args, **kwargs) - - mock_coro.mock = m - return mock_coro - - def _run(coro): """Run the given coroutine.""" return asyncio.get_event_loop().run_until_complete(coro) @@ -57,11 +46,11 @@ def _get_mock_socket(self): mock_socket.closed = False mock_socket.closing = False mock_socket.upgraded = False - mock_socket.send = AsyncMock() - mock_socket.handle_get_request = AsyncMock() - mock_socket.handle_post_request = AsyncMock() - mock_socket.check_ping_timeout = AsyncMock() - mock_socket.close = AsyncMock() + mock_socket.send = mock.AsyncMock() + mock_socket.handle_get_request = mock.AsyncMock() + mock_socket.handle_post_request = mock.AsyncMock() + mock_socket.check_ping_timeout = mock.AsyncMock() + mock_socket.close = mock.AsyncMock() mock_socket.session = {} return mock_socket @@ -143,8 +132,8 @@ def test_disconnect(self): s = async_server.AsyncServer() s.sockets['foo'] = mock_socket = self._get_mock_socket() _run(s.disconnect('foo')) - assert mock_socket.close.mock.call_count == 1 - mock_socket.close.mock.assert_called_once_with() + assert mock_socket.close.await_count == 1 + mock_socket.close.assert_awaited_once_with() assert 'foo' not in s.sockets def test_disconnect_all(self): @@ -152,10 +141,10 @@ def test_disconnect_all(self): s.sockets['foo'] = mock_foo = self._get_mock_socket() s.sockets['bar'] = mock_bar = self._get_mock_socket() _run(s.disconnect()) - assert mock_foo.close.mock.call_count == 1 - assert mock_bar.close.mock.call_count == 1 - mock_foo.close.mock.assert_called_once_with() - mock_bar.close.mock.assert_called_once_with() + assert mock_foo.close.await_count == 1 + assert mock_bar.close.await_count == 1 + mock_foo.close.assert_awaited_once_with() + mock_bar.close.assert_awaited_once_with() assert 'foo' not in s.sockets assert 'bar' not in s.sockets @@ -215,23 +204,23 @@ def test_connect(self, import_module): @mock.patch('importlib.import_module') def test_connect_async_request_response_handlers(self, import_module): a = self.get_async_mock() - a._async['translate_request'] = AsyncMock( + a._async['translate_request'] = mock.AsyncMock( return_value=a._async['translate_request'].return_value ) - a._async['make_response'] = AsyncMock( + a._async['make_response'] = mock.AsyncMock( return_value=a._async['make_response'].return_value ) import_module.side_effect = [a] s = async_server.AsyncServer() _run(s.handle_request('request')) assert len(s.sockets) == 1 - assert a._async['make_response'].mock.call_count == 1 - assert a._async['make_response'].mock.call_args[0][0] == '200 OK' + assert a._async['make_response'].await_count == 1 + assert a._async['make_response'].await_args[0][0] == '200 OK' assert ('Content-Type', 'text/plain; charset=UTF-8') in a._async[ 'make_response' - ].mock.call_args[0][1] + ].await_args[0][1] packets = payload.Payload( - encoded_payload=a._async['make_response'].mock.call_args[0][ + encoded_payload=a._async['make_response'].await_args[0][ 2].decode('utf-8')).packets assert len(packets) == 1 assert packets[0].packet_type == packet.OPEN @@ -305,7 +294,7 @@ def test_connect_transport_websocket(self, AsyncSocket, import_module): AsyncSocket().closed = False _run(s.handle_request('request')) assert ( - s.sockets['123'].send.mock.call_args[0][0].packet_type + s.sockets['123'].send.await_args[0][0].packet_type == packet.OPEN ) @@ -327,7 +316,7 @@ def test_http_upgrade_case_insensitive(self, AsyncSocket, import_module): AsyncSocket().closed = False _run(s.handle_request('request')) assert ( - s.sockets['123'].send.mock.call_args[0][0].packet_type + s.sockets['123'].send.await_args[0][0].packet_type == packet.OPEN ) @@ -443,16 +432,16 @@ def test_connect_cors_not_allowed_origin_async_response( a = self.get_async_mock( {'REQUEST_METHOD': 'GET', 'QUERY_STRING': '', 'HTTP_ORIGIN': 'c'} ) - a._async['make_response'] = AsyncMock( + a._async['make_response'] = mock.AsyncMock( return_value=a._async['make_response'].return_value ) import_module.side_effect = [a] s = async_server.AsyncServer(cors_allowed_origins=['a', 'b']) _run(s.handle_request('request')) assert ( - a._async['make_response'].mock.call_args[0][0] == '400 BAD REQUEST' + a._async['make_response'].await_args[0][0] == '400 BAD REQUEST' ) - headers = a._async['make_response'].mock.call_args[0][1] + headers = a._async['make_response'].await_args[0][1] assert ('Access-Control-Allow-Origin', 'c') not in headers assert ('Access-Control-Allow-Origin', '*') not in headers @@ -702,11 +691,11 @@ def test_send(self, import_module): s = async_server.AsyncServer() s.sockets['foo'] = mock_socket = self._get_mock_socket() _run(s.send('foo', 'hello')) - assert mock_socket.send.mock.call_count == 1 + assert mock_socket.send.await_count == 1 assert ( - mock_socket.send.mock.call_args[0][0].packet_type == packet.MESSAGE + mock_socket.send.await_args[0][0].packet_type == packet.MESSAGE ) - assert mock_socket.send.mock.call_args[0][0].data == 'hello' + assert mock_socket.send.await_args[0][0].data == 'hello' @mock.patch('importlib.import_module') def test_send_unknown_socket(self, import_module): @@ -724,7 +713,7 @@ def test_get_request(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer() s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -744,7 +733,7 @@ def test_get_request_custom_response(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer() s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = 'resp' + mock_socket.handle_get_request.return_value = 'resp' r = _run(s.handle_request('request')) assert r == 'resp' @@ -828,7 +817,7 @@ def test_gzip_compression(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer(compression_threshold=0) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -848,7 +837,7 @@ def test_deflate_compression(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer(compression_threshold=0) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -868,7 +857,7 @@ def test_gzip_compression_threshold(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer(compression_threshold=1000) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -892,7 +881,7 @@ def test_compression_disabled(self, import_module): http_compression=False, compression_threshold=0 ) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -914,7 +903,7 @@ def test_compression_unknown(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer(compression_threshold=0) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -936,7 +925,7 @@ def test_compression_no_encoding(self, import_module): import_module.side_effect = [a] s = async_server.AsyncServer(compression_threshold=0) s.sockets['foo'] = mock_socket = self._get_mock_socket() - mock_socket.handle_get_request.mock.return_value = [ + mock_socket.handle_get_request.return_value = [ packet.Packet(packet.MESSAGE, data='hello') ] _run(s.handle_request('request')) @@ -1162,9 +1151,9 @@ def test_service_task_started(self, import_module): a = self.get_async_mock() import_module.side_effect = [a] s = async_server.AsyncServer(monitor_clients=True) - s._service_task = AsyncMock() + s._service_task = mock.AsyncMock() _run(s.handle_request('request')) - s._service_task.mock.assert_called_once_with() + s._service_task.assert_awaited_once_with() @mock.patch('importlib.import_module') def test_shutdown(self, import_module): diff --git a/tests/async/test_socket.py b/tests/async/test_socket.py index dad2baa6..56a43ac4 100644 --- a/tests/async/test_socket.py +++ b/tests/async/test_socket.py @@ -10,17 +10,6 @@ from engineio import payload -def AsyncMock(*args, **kwargs): - """Return a mock asynchronous function.""" - m = mock.MagicMock(*args, **kwargs) - - async def mock_coro(*args, **kwargs): - return m(*args, **kwargs) - - mock_coro.mock = m - return mock_coro - - def _run(coro): """Run the given coroutine.""" return asyncio.get_event_loop().run_until_complete(coro) @@ -29,8 +18,8 @@ def _run(coro): class TestSocket: def _get_read_mock_coro(self, payload): mock_input = mock.MagicMock() - mock_input.read = AsyncMock() - mock_input.read.mock.return_value = payload + mock_input.read = mock.AsyncMock() + mock_input.read.return_value = payload return mock_input def _get_mock_server(self): @@ -49,7 +38,7 @@ def _get_mock_server(self): } mock_server._async['translate_request'].return_value = 'request' mock_server._async['make_response'].return_value = 'response' - mock_server._trigger_event = AsyncMock() + mock_server._trigger_event = mock.AsyncMock() def bg_task(target, *args, **kwargs): return asyncio.ensure_future(target(*args, **kwargs)) @@ -109,7 +98,7 @@ def test_schedule_ping(self): mock_server = self._get_mock_server() mock_server.ping_interval = 0.01 s = async_socket.AsyncSocket(mock_server, 'sid') - s.send = AsyncMock() + s.send = mock.AsyncMock() async def schedule_ping(): s.schedule_ping() @@ -117,13 +106,13 @@ async def schedule_ping(): _run(schedule_ping()) assert s.last_ping is not None - assert s.send.mock.call_args_list[0][0][0].encode() == '2' + assert s.send.await_args_list[0][0][0].encode() == '2' def test_schedule_ping_closed_socket(self): mock_server = self._get_mock_server() mock_server.ping_interval = 0.01 s = async_socket.AsyncSocket(mock_server, 'sid') - s.send = AsyncMock() + s.send = mock.AsyncMock() s.closed = True async def schedule_ping(): @@ -132,7 +121,7 @@ async def schedule_ping(): _run(schedule_ping()) assert s.last_ping is None - s.send.mock.assert_not_called() + s.send.assert_not_awaited() def test_pong(self): mock_server = self._get_mock_server() @@ -145,7 +134,7 @@ def test_message_sync_handler(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') _run(s.receive(packet.Packet(packet.MESSAGE, data='foo'))) - mock_server._trigger_event.mock.assert_called_once_with( + mock_server._trigger_event.assert_awaited_once_with( 'message', 'sid', 'foo', run_async=False ) @@ -154,7 +143,7 @@ def test_message_async_handler(self): s = async_socket.AsyncSocket(mock_server, 'sid') mock_server.async_handlers = True _run(s.receive(packet.Packet(packet.MESSAGE, data='foo'))) - mock_server._trigger_event.mock.assert_called_once_with( + mock_server._trigger_event.assert_awaited_once_with( 'message', 'sid', 'foo', run_async=True ) @@ -170,9 +159,9 @@ def test_timeout(self): mock_server.ping_interval_grace_period = 2 s = async_socket.AsyncSocket(mock_server, 'sid') s.last_ping = time.time() - 9 - s.close = AsyncMock() + s.close = mock.AsyncMock() _run(s.send('packet')) - s.close.mock.assert_called_once_with(wait=False, abort=False) + s.close.assert_awaited_once_with(wait=False, abort=False) def test_polling_read(self): mock_server = self._get_mock_server() @@ -199,7 +188,7 @@ def test_polling_write(self): pkt2 = packet.Packet(packet.MESSAGE, data='bye') p = payload.Payload(packets=[pkt1, pkt2]).encode().encode('utf-8') s = async_socket.AsyncSocket(mock_server, 'foo') - s.receive = AsyncMock() + s.receive = mock.AsyncMock() environ = { 'REQUEST_METHOD': 'POST', 'QUERY_STRING': 'sid=foo', @@ -207,7 +196,7 @@ def test_polling_write(self): 'wsgi.input': self._get_read_mock_coro(p), } _run(s.handle_post_request(environ)) - assert s.receive.mock.call_count == 2 + assert s.receive.await_count == 2 def test_polling_write_too_large(self): mock_server = self._get_mock_server() @@ -216,7 +205,7 @@ def test_polling_write_too_large(self): p = payload.Payload(packets=[pkt1, pkt2]).encode().encode('utf-8') mock_server.max_http_buffer_size = len(p) - 1 s = async_socket.AsyncSocket(mock_server, 'foo') - s.receive = AsyncMock() + s.receive = mock.AsyncMock() environ = { 'REQUEST_METHOD': 'POST', 'QUERY_STRING': 'sid=foo', @@ -229,7 +218,7 @@ def test_polling_write_too_large(self): def test_upgrade_handshake(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'foo') - s._upgrade_websocket = AsyncMock() + s._upgrade_websocket = mock.AsyncMock() environ = { 'REQUEST_METHOD': 'GET', 'QUERY_STRING': 'sid=foo', @@ -237,12 +226,12 @@ def test_upgrade_handshake(self): 'HTTP_UPGRADE': 'websocket', } _run(s.handle_get_request(environ)) - s._upgrade_websocket.mock.assert_called_once_with(environ) + s._upgrade_websocket.assert_awaited_once_with(environ) def test_upgrade(self): mock_server = self._get_mock_server() mock_server._async['websocket'] = mock.MagicMock() - mock_ws = AsyncMock() + mock_ws = mock.AsyncMock() mock_server._async['websocket'].return_value = mock_ws s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True @@ -251,7 +240,7 @@ def test_upgrade(self): mock_server._async['websocket'].assert_called_once_with( s._websocket_handler, mock_server ) - mock_ws.mock.assert_called_once_with(environ) + mock_ws.assert_awaited_once_with(environ) def test_upgrade_twice(self): mock_server = self._get_mock_server() @@ -277,8 +266,8 @@ def test_upgrade_no_probe(self): s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True ws = mock.MagicMock() - ws.wait = AsyncMock() - ws.wait.mock.return_value = packet.Packet(packet.NOOP).encode() + ws.wait = mock.AsyncMock() + ws.wait.return_value = packet.Packet(packet.NOOP).encode() _run(s._websocket_handler(ws)) assert not s.upgraded @@ -286,17 +275,17 @@ def test_upgrade_no_upgrade_packet(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() probe = 'probe' - ws.wait.mock.side_effect = [ + ws.wait.side_effect = [ packet.Packet(packet.PING, data=probe).encode(), packet.Packet(packet.NOOP).encode(), ] _run(s._websocket_handler(ws)) - ws.send.mock.assert_called_once_with( + ws.send.assert_awaited_once_with( packet.Packet(packet.PONG, data=probe).encode() ) assert _run(s.queue.get()).packet_type == packet.NOOP @@ -315,91 +304,91 @@ def test_close_packet(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.close = AsyncMock() + s.close = mock.AsyncMock() _run(s.receive(packet.Packet(packet.CLOSE))) - s.close.mock.assert_called_once_with(wait=False, abort=True) + s.close.assert_awaited_once_with(wait=False, abort=True) def test_websocket_read_write(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = False - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) foo = 'foo' bar = 'bar' - s.poll = AsyncMock( + s.poll = mock.AsyncMock( side_effect=[[packet.Packet(packet.MESSAGE, data=bar)], None] ) ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.MESSAGE, data=foo).encode(), None, ] - ws.close = AsyncMock() + ws.close = mock.AsyncMock() _run(s._websocket_handler(ws)) assert s.connected assert s.upgraded - assert mock_server._trigger_event.mock.call_count == 2 - mock_server._trigger_event.mock.assert_has_calls( + assert mock_server._trigger_event.await_count == 2 + mock_server._trigger_event.assert_has_awaits( [ mock.call('message', 'sid', 'foo', run_async=False), mock.call('disconnect', 'sid'), ] ) - ws.send.mock.assert_called_with('4bar') - ws.close.mock.assert_called() + ws.send.assert_awaited_with('4bar') + ws.close.assert_awaited() def test_websocket_upgrade_read_write(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) foo = 'foo' bar = 'bar' probe = 'probe' - s.poll = AsyncMock( + s.poll = mock.AsyncMock( side_effect=[ [packet.Packet(packet.MESSAGE, data=bar)], exceptions.QueueEmpty, ] ) ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.PING, data=probe).encode(), packet.Packet(packet.UPGRADE).encode(), packet.Packet(packet.MESSAGE, data=foo).encode(), None, ] - ws.close = AsyncMock() + ws.close = mock.AsyncMock() _run(s._websocket_handler(ws)) assert s.upgraded - assert mock_server._trigger_event.mock.call_count == 2 - mock_server._trigger_event.mock.assert_has_calls( + assert mock_server._trigger_event.await_count == 2 + mock_server._trigger_event.assert_has_awaits( [ mock.call('message', 'sid', 'foo', run_async=False), mock.call('disconnect', 'sid'), ] ) - ws.send.mock.assert_called_with('4bar') - ws.close.mock.assert_called() + ws.send.assert_awaited_with('4bar') + ws.close.assert_awaited() def test_websocket_upgrade_with_payload(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) probe = 'probe' ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.PING, data=probe).encode(), packet.Packet(packet.UPGRADE, data='2').encode(), ] - ws.close = AsyncMock() + ws.close = mock.AsyncMock() _run(s._websocket_handler(ws)) assert s.upgraded @@ -407,17 +396,17 @@ def test_websocket_upgrade_with_backlog(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) probe = 'probe' foo = 'foo' ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.PING, data=probe).encode(), packet.Packet(packet.UPGRADE, data='2').encode(), ] - ws.close = AsyncMock() + ws.close = mock.AsyncMock() s.upgrading = True _run(s.send(packet.Packet(packet.MESSAGE, data=foo))) environ = {'REQUEST_METHOD': 'GET', 'QUERY_STRING': 'sid=sid'} @@ -439,10 +428,10 @@ def test_websocket_read_write_wait_fail(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = False - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) foo = 'foo' bar = 'bar' - s.poll = AsyncMock( + s.poll = mock.AsyncMock( side_effect=[ [packet.Packet(packet.MESSAGE, data=bar)], [packet.Packet(packet.MESSAGE, data=bar)], @@ -450,14 +439,14 @@ def test_websocket_read_write_wait_fail(self): ] ) ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.MESSAGE, data=foo).encode(), RuntimeError, ] - ws.send.mock.side_effect = [None, RuntimeError] - ws.close = AsyncMock() + ws.send.side_effect = [None, RuntimeError] + ws.close = mock.AsyncMock() _run(s._websocket_handler(ws)) assert s.closed @@ -465,12 +454,12 @@ def test_websocket_upgrade_with_large_packet(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = True - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) probe = 'probe' ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.PING, data=probe).encode(), packet.Packet(packet.UPGRADE, data='2' * 128).encode(), ] @@ -482,35 +471,35 @@ def test_websocket_ignore_invalid_packet(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.connected = False - s.queue.join = AsyncMock(return_value=None) + s.queue.join = mock.AsyncMock(return_value=None) foo = 'foo' bar = 'bar' - s.poll = AsyncMock( + s.poll = mock.AsyncMock( side_effect=[ [packet.Packet(packet.MESSAGE, data=bar)], exceptions.QueueEmpty, ] ) ws = mock.MagicMock() - ws.send = AsyncMock() - ws.wait = AsyncMock() - ws.wait.mock.side_effect = [ + ws.send = mock.AsyncMock() + ws.wait = mock.AsyncMock() + ws.wait.side_effect = [ packet.Packet(packet.OPEN).encode(), packet.Packet(packet.MESSAGE, data=foo).encode(), None, ] - ws.close = AsyncMock() + ws.close = mock.AsyncMock() _run(s._websocket_handler(ws)) assert s.connected - assert mock_server._trigger_event.mock.call_count == 2 - mock_server._trigger_event.mock.assert_has_calls( + assert mock_server._trigger_event.await_count == 2 + mock_server._trigger_event.assert_has_awaits( [ mock.call('message', 'sid', foo, run_async=False), mock.call('disconnect', 'sid'), ] ) - ws.send.mock.assert_called_with('4bar') - ws.close.mock.assert_called() + ws.send.assert_awaited_with('4bar') + ws.close.assert_awaited() def test_send_after_close(self): mock_server = self._get_mock_server() @@ -524,27 +513,27 @@ def test_close_after_close(self): s = async_socket.AsyncSocket(mock_server, 'sid') _run(s.close(wait=False)) assert s.closed - assert mock_server._trigger_event.mock.call_count == 1 - mock_server._trigger_event.mock.assert_called_once_with( + assert mock_server._trigger_event.await_count == 1 + mock_server._trigger_event.assert_awaited_once_with( 'disconnect', 'sid' ) _run(s.close()) - assert mock_server._trigger_event.mock.call_count == 1 + assert mock_server._trigger_event.await_count == 1 def test_close_and_wait(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.queue = mock.MagicMock() - s.queue.put = AsyncMock() - s.queue.join = AsyncMock() + s.queue.put = mock.AsyncMock() + s.queue.join = mock.AsyncMock() _run(s.close(wait=True)) - s.queue.join.mock.assert_called_once_with() + s.queue.join.assert_awaited_once_with() def test_close_without_wait(self): mock_server = self._get_mock_server() s = async_socket.AsyncSocket(mock_server, 'sid') s.queue = mock.MagicMock() - s.queue.put = AsyncMock() - s.queue.join = AsyncMock() + s.queue.put = mock.AsyncMock() + s.queue.join = mock.AsyncMock() _run(s.close(wait=False)) - assert s.queue.join.mock.call_count == 0 + assert s.queue.join.await_count == 0