diff --git a/pyproject.toml b/pyproject.toml index 54ba9d9..8a5453a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -54,3 +54,7 @@ namespaces = false [build-system] requires = ["setuptools>=61.2"] build-backend = "setuptools.build_meta" + +[tool.pytest.ini_options] +asyncio_mode = "auto" +asyncio_default_fixture_loop_scope = "session" diff --git a/tests/async/helpers.py b/tests/async/helpers.py deleted file mode 100644 index c9b708c..0000000 --- a/tests/async/helpers.py +++ /dev/null @@ -1,6 +0,0 @@ -import asyncio - - -def _run(coro): - """Run the given coroutine.""" - return asyncio.get_event_loop().run_until_complete(coro) diff --git a/tests/async/test_client.py b/tests/async/test_client.py index 289abd9..26681b7 100644 --- a/tests/async/test_client.py +++ b/tests/async/test_client.py @@ -8,27 +8,24 @@ from socketio import async_namespace from engineio import exceptions as engineio_exceptions from socketio import exceptions from socketio import packet -from .helpers import _run class TestAsyncClient: - def test_is_asyncio_based(self): + async def test_is_asyncio_based(self): c = async_client.AsyncClient() assert c.is_asyncio_based() - def test_connect(self): + async def test_connect(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() - _run( - c.connect( - 'url', - headers='headers', - auth='auth', - transports='transports', - namespaces=['/foo', '/', '/bar'], - socketio_path='path', - wait=False, - ) + await c.connect( + 'url', + headers='headers', + auth='auth', + transports='transports', + namespaces=['/foo', '/', '/bar'], + socketio_path='path', + wait=False, ) assert c.connection_url == 'url' assert c.connection_headers == 'headers' @@ -43,22 +40,20 @@ class TestAsyncClient: engineio_path='path', ) - def test_connect_functions(self): + async def test_connect_functions(self): async def headers(): return 'headers' c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() - _run( - c.connect( - lambda: 'url', - headers=headers, - auth='auth', - transports='transports', - namespaces=['/foo', '/', '/bar'], - socketio_path='path', - wait=False, - ) + await c.connect( + lambda: 'url', + headers=headers, + auth='auth', + transports='transports', + namespaces=['/foo', '/', '/bar'], + socketio_path='path', + wait=False, ) c.eio.connect.assert_awaited_once_with( 'url', @@ -67,18 +62,16 @@ class TestAsyncClient: engineio_path='path', ) - def test_connect_one_namespace(self): + async def test_connect_one_namespace(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() - _run( - c.connect( - 'url', - headers='headers', - transports='transports', - namespaces='/foo', - socketio_path='path', - wait=False, - ) + await c.connect( + 'url', + headers='headers', + transports='transports', + namespaces='/foo', + socketio_path='path', + wait=False, ) assert c.connection_url == 'url' assert c.connection_headers == 'headers' @@ -92,20 +85,18 @@ class TestAsyncClient: engineio_path='path', ) - def test_connect_default_namespaces(self): + async def test_connect_default_namespaces(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() c.on('foo', mock.MagicMock(), namespace='/foo') c.on('bar', mock.MagicMock(), namespace='/') c.on('baz', mock.MagicMock(), namespace='*') - _run( - c.connect( - 'url', - headers='headers', - transports='transports', - socketio_path='path', - wait=False, - ) + await c.connect( + 'url', + headers='headers', + transports='transports', + socketio_path='path', + wait=False, ) assert c.connection_url == 'url' assert c.connection_headers == 'headers' @@ -120,17 +111,15 @@ class TestAsyncClient: engineio_path='path', ) - def test_connect_no_namespaces(self): + async def test_connect_no_namespaces(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() - _run( - c.connect( - 'url', - headers='headers', - transports='transports', - socketio_path='path', - wait=False, - ) + await c.connect( + 'url', + headers='headers', + transports='transports', + socketio_path='path', + wait=False, ) assert c.connection_url == 'url' assert c.connection_headers == 'headers' @@ -144,7 +133,7 @@ class TestAsyncClient: engineio_path='path', ) - def test_connect_error(self): + async def test_connect_error(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock( side_effect=engineio_exceptions.ConnectionError('foo') @@ -152,34 +141,28 @@ class TestAsyncClient: c.on('foo', mock.MagicMock(), namespace='/foo') c.on('bar', mock.MagicMock(), namespace='/') with pytest.raises(exceptions.ConnectionError): - _run( - c.connect( - 'url', - headers='headers', - transports='transports', - socketio_path='path', - wait=False, - ) + await c.connect( + 'url', + headers='headers', + transports='transports', + socketio_path='path', + wait=False, ) - def test_connect_twice(self): + async def test_connect_twice(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() - _run( - c.connect( - 'url', - wait=False, - ) + await c.connect( + 'url', + wait=False, ) with pytest.raises(exceptions.ConnectionError): - _run( - c.connect( - 'url', - wait=False, - ) + await c.connect( + 'url', + wait=False, ) - def test_connect_wait_single_namespace(self): + async def test_connect_wait_single_namespace(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() c._connect_event = mock.MagicMock() @@ -189,16 +172,14 @@ class TestAsyncClient: return True c._connect_event.wait = mock_connect - _run( - c.connect( - 'url', - wait=True, - wait_timeout=0.01, - ) + await c.connect( + 'url', + wait=True, + wait_timeout=0.01, ) assert c.connected is True - def test_connect_wait_two_namespaces(self): + async def test_connect_wait_two_namespaces(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() c._connect_event = mock.MagicMock() @@ -213,41 +194,37 @@ class TestAsyncClient: return False c._connect_event.wait = mock_connect - _run( - c.connect( - 'url', - namespaces=['/foo', '/bar'], - wait=True, - wait_timeout=0.01, - ) + await c.connect( + 'url', + namespaces=['/foo', '/bar'], + wait=True, + wait_timeout=0.01, ) assert c.connected is True assert c.namespaces == {'/bar': '123', '/foo': '456'} - def test_connect_timeout(self): + async def test_connect_timeout(self): c = async_client.AsyncClient() c.eio.connect = mock.AsyncMock() c.disconnect = mock.AsyncMock() with pytest.raises(exceptions.ConnectionError): - _run( - c.connect( - 'url', - wait=True, - wait_timeout=0.01, - ) + await c.connect( + 'url', + wait=True, + wait_timeout=0.01, ) c.disconnect.assert_awaited_once_with() - def test_wait_no_reconnect(self): + async def test_wait_no_reconnect(self): c = async_client.AsyncClient() c.eio.wait = mock.AsyncMock() c.sleep = mock.AsyncMock() c._reconnect_task = None - _run(c.wait()) + await c.wait() c.eio.wait.assert_awaited_once_with() c.sleep.assert_awaited_once_with(1) - def test_wait_reconnect_failed(self): + async def test_wait_reconnect_failed(self): c = async_client.AsyncClient() c.eio.wait = mock.AsyncMock() c.sleep = mock.AsyncMock() @@ -257,11 +234,11 @@ class TestAsyncClient: c.eio.state = states.pop(0) c._reconnect_task = fake_wait() - _run(c.wait()) + await c.wait() c.eio.wait.assert_awaited_once_with() c.sleep.assert_awaited_once_with(1) - def test_wait_reconnect_successful(self): + async def test_wait_reconnect_successful(self): c = async_client.AsyncClient() c.eio.wait = mock.AsyncMock() c.sleep = mock.AsyncMock() @@ -272,15 +249,15 @@ class TestAsyncClient: c._reconnect_task = fake_wait() c._reconnect_task = fake_wait() - _run(c.wait()) + await c.wait() assert c.eio.wait.await_count == 2 assert c.sleep.await_count == 2 - def test_emit_no_arguments(self): + async def test_emit_no_arguments(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo')) + await c.emit('foo') expected_packet = packet.Packet( packet.EVENT, namespace='/', data=['foo'], id=None) assert c._send_packet.await_count == 1 @@ -289,11 +266,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_one_argument(self): + async def test_emit_one_argument(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', 'bar')) + await c.emit('foo', 'bar') expected_packet = packet.Packet( packet.EVENT, namespace='/', @@ -306,11 +283,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_one_argument_list(self): + async def test_emit_one_argument_list(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', ['bar', 'baz'])) + await c.emit('foo', ['bar', 'baz']) expected_packet = packet.Packet( packet.EVENT, namespace='/', @@ -323,11 +300,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_two_arguments(self): + async def test_emit_two_arguments(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', ('bar', 'baz'))) + await c.emit('foo', ('bar', 'baz')) expected_packet = packet.Packet( packet.EVENT, namespace='/', @@ -340,11 +317,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_namespace(self): + async def test_emit_namespace(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', namespace='/foo')) + await c.emit('foo', namespace='/foo') expected_packet = packet.Packet( packet.EVENT, namespace='/foo', data=['foo'], id=None) assert c._send_packet.await_count == 1 @@ -353,18 +330,18 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_unknown_namespace(self): + async def test_emit_unknown_namespace(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1'} with pytest.raises(exceptions.BadNamespaceError): - _run(c.emit('foo', namespace='/bar')) + await c.emit('foo', namespace='/bar') - def test_emit_with_callback(self): + async def test_emit_with_callback(self): c = async_client.AsyncClient() c._send_packet = mock.AsyncMock() c._generate_ack_id = mock.MagicMock(return_value=123) c.namespaces = {'/': '1'} - _run(c.emit('foo', callback='cb')) + await c.emit('foo', callback='cb') expected_packet = packet.Packet( packet.EVENT, namespace='/', data=['foo'], id=123) assert c._send_packet.await_count == 1 @@ -374,12 +351,12 @@ class TestAsyncClient: ) c._generate_ack_id.assert_called_once_with('/', 'cb') - def test_emit_namespace_with_callback(self): + async def test_emit_namespace_with_callback(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1'} c._send_packet = mock.AsyncMock() c._generate_ack_id = mock.MagicMock(return_value=123) - _run(c.emit('foo', namespace='/foo', callback='cb')) + await c.emit('foo', namespace='/foo', callback='cb') expected_packet = packet.Packet( packet.EVENT, namespace='/foo', data=['foo'], id=123) assert c._send_packet.await_count == 1 @@ -389,11 +366,11 @@ class TestAsyncClient: ) c._generate_ack_id.assert_called_once_with('/foo', 'cb') - def test_emit_binary(self): + async def test_emit_binary(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', b'bar')) + await c.emit('foo', b'bar') expected_packet = packet.Packet( packet.EVENT, namespace='/', @@ -406,11 +383,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_emit_not_binary(self): + async def test_emit_not_binary(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c._send_packet = mock.AsyncMock() - _run(c.emit('foo', 'bar')) + await c.emit('foo', 'bar') expected_packet = packet.Packet( packet.EVENT, namespace='/', @@ -423,23 +400,23 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_send(self): + async def test_send(self): c = async_client.AsyncClient() c.emit = mock.AsyncMock() - _run(c.send('data', 'namespace', 'callback')) + await c.send('data', 'namespace', 'callback') c.emit.assert_awaited_once_with( 'message', data='data', namespace='namespace', callback='callback' ) - def test_send_with_defaults(self): + async def test_send_with_defaults(self): c = async_client.AsyncClient() c.emit = mock.AsyncMock() - _run(c.send('data')) + await c.send('data') c.emit.assert_awaited_once_with( 'message', data='data', namespace=None, callback=None ) - def test_call(self): + async def test_call(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} @@ -450,7 +427,7 @@ class TestAsyncClient: c._generate_ack_id = mock.MagicMock(return_value=123) c.eio = mock.MagicMock() c.eio.create_event.return_value.wait = fake_event_wait - assert _run(c.call('foo')) == ('foo', 321) + assert await c.call('foo') == ('foo', 321) expected_packet = packet.Packet( packet.EVENT, namespace='/', data=['foo'], id=123) assert c._send_packet.await_count == 1 @@ -459,7 +436,7 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_call_with_timeout(self): + async def test_call_with_timeout(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} @@ -471,7 +448,7 @@ class TestAsyncClient: c.eio = mock.MagicMock() c.eio.create_event.return_value.wait = fake_event_wait with pytest.raises(exceptions.TimeoutError): - _run(c.call('foo', timeout=0.01)) + await c.call('foo', timeout=0.01) expected_packet = packet.Packet( packet.EVENT, namespace='/', data=['foo'], id=123) assert c._send_packet.await_count == 1 @@ -480,7 +457,7 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_disconnect(self): + async def test_disconnect(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/': '1'} @@ -489,7 +466,7 @@ class TestAsyncClient: c.eio = mock.MagicMock() c.eio.disconnect = mock.AsyncMock() c.eio.state = 'connected' - _run(c.disconnect()) + await c.disconnect() assert c.connected assert c._trigger_event.await_count == 0 assert c._send_packet.await_count == 1 @@ -500,7 +477,7 @@ class TestAsyncClient: ) c.eio.disconnect.assert_awaited_once_with(abort=True) - def test_disconnect_namespaces(self): + async def test_disconnect_namespaces(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1', '/bar': '2'} c._trigger_event = mock.AsyncMock() @@ -508,7 +485,7 @@ class TestAsyncClient: c.eio = mock.MagicMock() c.eio.disconnect = mock.AsyncMock() c.eio.state = 'connected' - _run(c.disconnect()) + await c.disconnect() assert c._trigger_event.await_count == 0 assert c._send_packet.await_count == 2 expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo') @@ -522,7 +499,7 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_start_background_task(self): + async def test_start_background_task(self): c = async_client.AsyncClient() c.eio.start_background_task = mock.MagicMock(return_value='foo') assert c.start_background_task('foo', 'bar', baz='baz') == 'foo' @@ -530,22 +507,22 @@ class TestAsyncClient: 'foo', 'bar', baz='baz' ) - def test_sleep(self): + async def test_sleep(self): c = async_client.AsyncClient() c.eio.sleep = mock.AsyncMock() - _run(c.sleep(1.23)) + await c.sleep(1.23) c.eio.sleep.assert_awaited_once_with(1.23) - def test_send_packet(self): + async def test_send_packet(self): c = async_client.AsyncClient() c.eio.send = mock.AsyncMock() - _run(c._send_packet(packet.Packet(packet.EVENT, 'foo'))) + await c._send_packet(packet.Packet(packet.EVENT, 'foo')) c.eio.send.assert_awaited_once_with('2"foo"') - def test_send_packet_binary(self): + async def test_send_packet_binary(self): c = async_client.AsyncClient() c.eio.send = mock.AsyncMock() - _run(c._send_packet(packet.Packet(packet.EVENT, b'foo'))) + await c._send_packet(packet.Packet(packet.EVENT, b'foo')) assert c.eio.send.await_args_list == [ mock.call('51-{"_placeholder":true,"num":0}'), mock.call(b'foo'), @@ -554,52 +531,52 @@ class TestAsyncClient: mock.call(b'foo'), ] - def test_send_packet_default_binary(self): + async def test_send_packet_default_binary(self): c = async_client.AsyncClient() c.eio.send = mock.AsyncMock() - _run(c._send_packet(packet.Packet(packet.EVENT, 'foo'))) + await c._send_packet(packet.Packet(packet.EVENT, 'foo')) c.eio.send.assert_awaited_once_with('2"foo"') - def test_handle_connect(self): + async def test_handle_connect(self): c = async_client.AsyncClient() c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() c._send_packet = mock.AsyncMock() - _run(c._handle_connect('/', {'sid': '123'})) + await c._handle_connect('/', {'sid': '123'}) c._connect_event.set.assert_called_once_with() c._trigger_event.assert_awaited_once_with('connect', namespace='/') c._send_packet.assert_not_awaited() - def test_handle_connect_with_namespaces(self): + async def test_handle_connect_with_namespaces(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1', '/bar': '2'} c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() c._send_packet = mock.AsyncMock() - _run(c._handle_connect('/', {'sid': '3'})) + await c._handle_connect('/', {'sid': '3'}) c._connect_event.set.assert_called_once_with() c._trigger_event.assert_awaited_once_with('connect', namespace='/') assert c.namespaces == {'/': '3', '/foo': '1', '/bar': '2'} - def test_handle_connect_namespace(self): + async def test_handle_connect_namespace(self): c = async_client.AsyncClient() c.namespaces = {'/foo': '1'} c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() c._send_packet = mock.AsyncMock() - _run(c._handle_connect('/foo', {'sid': '123'})) - _run(c._handle_connect('/bar', {'sid': '2'})) + await c._handle_connect('/foo', {'sid': '123'}) + await c._handle_connect('/bar', {'sid': '2'}) assert c._trigger_event.await_count == 1 c._connect_event.set.assert_called_once_with() c._trigger_event.assert_awaited_once_with( 'connect', namespace='/bar') assert c.namespaces == {'/foo': '1', '/bar': '2'} - def test_handle_disconnect(self): + async def test_handle_disconnect(self): c = async_client.AsyncClient() c.connected = True c._trigger_event = mock.AsyncMock() - _run(c._handle_disconnect('/')) + await c._handle_disconnect('/') c._trigger_event.assert_any_await( 'disconnect', namespace='/' ) @@ -607,15 +584,15 @@ class TestAsyncClient: '__disconnect_final', namespace='/' ) assert not c.connected - _run(c._handle_disconnect('/')) + await c._handle_disconnect('/') assert c._trigger_event.await_count == 2 - def test_handle_disconnect_namespace(self): + async def test_handle_disconnect_namespace(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._trigger_event = mock.AsyncMock() - _run(c._handle_disconnect('/foo')) + await c._handle_disconnect('/foo') c._trigger_event.assert_any_await( 'disconnect', namespace='/foo' ) @@ -624,7 +601,7 @@ class TestAsyncClient: ) assert c.namespaces == {'/bar': '2'} assert c.connected - _run(c._handle_disconnect('/bar')) + await c._handle_disconnect('/bar') c._trigger_event.assert_any_await( 'disconnect', namespace='/bar' ) @@ -634,12 +611,12 @@ class TestAsyncClient: assert c.namespaces == {} assert not c.connected - def test_handle_disconnect_unknown_namespace(self): + async def test_handle_disconnect_unknown_namespace(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._trigger_event = mock.AsyncMock() - _run(c._handle_disconnect('/baz')) + await c._handle_disconnect('/baz') c._trigger_event.assert_any_await( 'disconnect', namespace='/baz' ) @@ -649,30 +626,30 @@ class TestAsyncClient: assert c.namespaces == {'/foo': '1', '/bar': '2'} assert c.connected - def test_handle_disconnect_default_namespaces(self): + async def test_handle_disconnect_default_namespaces(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._trigger_event = mock.AsyncMock() - _run(c._handle_disconnect('/')) + await c._handle_disconnect('/') c._trigger_event.assert_any_await('disconnect', namespace='/') c._trigger_event.assert_any_await('__disconnect_final', namespace='/') assert c.namespaces == {'/foo': '1', '/bar': '2'} assert c.connected - def test_handle_event(self): + async def test_handle_event(self): c = async_client.AsyncClient() c._trigger_event = mock.AsyncMock() - _run(c._handle_event('/', None, ['foo', ('bar', 'baz')])) + await c._handle_event('/', None, ['foo', ('bar', 'baz')]) c._trigger_event.assert_awaited_once_with( 'foo', '/', ('bar', 'baz') ) - def test_handle_event_with_id_no_arguments(self): + async def test_handle_event_with_id_no_arguments(self): c = async_client.AsyncClient() c._trigger_event = mock.AsyncMock(return_value=None) c._send_packet = mock.AsyncMock() - _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')])) + await c._handle_event('/', 123, ['foo', ('bar', 'baz')]) c._trigger_event.assert_awaited_once_with( 'foo', '/', ('bar', 'baz') ) @@ -684,11 +661,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_event_with_id_one_argument(self): + async def test_handle_event_with_id_one_argument(self): c = async_client.AsyncClient() c._trigger_event = mock.AsyncMock(return_value='ret') c._send_packet = mock.AsyncMock() - _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')])) + await c._handle_event('/', 123, ['foo', ('bar', 'baz')]) c._trigger_event.assert_awaited_once_with( 'foo', '/', ('bar', 'baz') ) @@ -700,11 +677,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_event_with_id_one_list_argument(self): + async def test_handle_event_with_id_one_list_argument(self): c = async_client.AsyncClient() c._trigger_event = mock.AsyncMock(return_value=['a', 'b']) c._send_packet = mock.AsyncMock() - _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')])) + await c._handle_event('/', 123, ['foo', ('bar', 'baz')]) c._trigger_event.assert_awaited_once_with( 'foo', '/', ('bar', 'baz') ) @@ -716,11 +693,11 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_event_with_id_two_arguments(self): + async def test_handle_event_with_id_two_arguments(self): c = async_client.AsyncClient() c._trigger_event = mock.AsyncMock(return_value=('a', 'b')) c._send_packet = mock.AsyncMock() - _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')])) + await c._handle_event('/', 123, ['foo', ('bar', 'baz')]) c._trigger_event.assert_awaited_once_with( 'foo', '/', ('bar', 'baz') ) @@ -732,37 +709,37 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_ack(self): + async def test_handle_ack(self): c = async_client.AsyncClient() mock_cb = mock.MagicMock() c.callbacks['/foo'] = {123: mock_cb} - _run(c._handle_ack('/foo', 123, ['bar', 'baz'])) + await c._handle_ack('/foo', 123, ['bar', 'baz']) mock_cb.assert_called_once_with('bar', 'baz') assert 123 not in c.callbacks['/foo'] - def test_handle_ack_async(self): + async def test_handle_ack_async(self): c = async_client.AsyncClient() mock_cb = mock.AsyncMock() c.callbacks['/foo'] = {123: mock_cb} - _run(c._handle_ack('/foo', 123, ['bar', 'baz'])) + await c._handle_ack('/foo', 123, ['bar', 'baz']) mock_cb.assert_awaited_once_with('bar', 'baz') assert 123 not in c.callbacks['/foo'] - def test_handle_ack_not_found(self): + async def test_handle_ack_not_found(self): c = async_client.AsyncClient() mock_cb = mock.MagicMock() c.callbacks['/foo'] = {123: mock_cb} - _run(c._handle_ack('/foo', 124, ['bar', 'baz'])) + await c._handle_ack('/foo', 124, ['bar', 'baz']) mock_cb.assert_not_called() assert 123 in c.callbacks['/foo'] - def test_handle_error(self): + async def test_handle_error(self): c = async_client.AsyncClient() c.connected = True c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() c.namespaces = {'/foo': '1', '/bar': '2'} - _run(c._handle_error('/', 'error')) + await c._handle_error('/', 'error') assert c.namespaces == {} assert not c.connected c._connect_event.set.assert_called_once_with() @@ -770,25 +747,25 @@ class TestAsyncClient: 'connect_error', '/', 'error' ) - def test_handle_error_with_no_arguments(self): + async def test_handle_error_with_no_arguments(self): c = async_client.AsyncClient() c.connected = True c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() c.namespaces = {'/foo': '1', '/bar': '2'} - _run(c._handle_error('/', None)) + await c._handle_error('/', None) assert c.namespaces == {} assert not c.connected c._connect_event.set.assert_called_once_with() c._trigger_event.assert_awaited_once_with('connect_error', '/') - def test_handle_error_namespace(self): + async def test_handle_error_namespace(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() - _run(c._handle_error('/bar', ['error', 'message'])) + await c._handle_error('/bar', ['error', 'message']) assert c.namespaces == {'/foo': '1'} assert c.connected c._connect_event.set.assert_called_once_with() @@ -796,52 +773,52 @@ class TestAsyncClient: 'connect_error', '/bar', 'error', 'message' ) - def test_handle_error_namespace_with_no_arguments(self): + async def test_handle_error_namespace_with_no_arguments(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._connect_event = mock.MagicMock() c._trigger_event = mock.AsyncMock() - _run(c._handle_error('/bar', None)) + await c._handle_error('/bar', None) assert c.namespaces == {'/foo': '1'} assert c.connected c._connect_event.set.assert_called_once_with() c._trigger_event.assert_awaited_once_with('connect_error', '/bar') - def test_handle_error_unknown_namespace(self): + async def test_handle_error_unknown_namespace(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} c._connect_event = mock.MagicMock() - _run(c._handle_error('/baz', 'error')) + await c._handle_error('/baz', 'error') assert c.namespaces == {'/foo': '1', '/bar': '2'} assert c.connected c._connect_event.set.assert_called_once_with() - def test_trigger_event(self): + async def test_trigger_event(self): c = async_client.AsyncClient() handler = mock.MagicMock() catchall_handler = mock.MagicMock() c.on('foo', handler) c.on('*', catchall_handler) - _run(c._trigger_event('foo', '/', 1, '2')) - _run(c._trigger_event('bar', '/', 1, '2', 3)) - _run(c._trigger_event('connect', '/')) # should not trigger + await c._trigger_event('foo', '/', 1, '2') + await c._trigger_event('bar', '/', 1, '2', 3) + await c._trigger_event('connect', '/') # should not trigger handler.assert_called_once_with(1, '2') catchall_handler.assert_called_once_with('bar', 1, '2', 3) - def test_trigger_event_namespace(self): + async def test_trigger_event_namespace(self): c = async_client.AsyncClient() handler = mock.AsyncMock() catchall_handler = mock.AsyncMock() c.on('foo', handler, namespace='/bar') c.on('*', catchall_handler, namespace='/bar') - _run(c._trigger_event('foo', '/bar', 1, '2')) - _run(c._trigger_event('bar', '/bar', 1, '2', 3)) + await c._trigger_event('foo', '/bar', 1, '2') + await c._trigger_event('bar', '/bar', 1, '2', 3) handler.assert_awaited_once_with(1, '2') catchall_handler.assert_awaited_once_with('bar', 1, '2', 3) - def test_trigger_event_class_namespace(self): + async def test_trigger_event_class_namespace(self): c = async_client.AsyncClient() result = [] @@ -851,10 +828,10 @@ class TestAsyncClient: result.append(b) c.register_namespace(MyNamespace('/')) - _run(c._trigger_event('foo', '/', 1, '2')) + await c._trigger_event('foo', '/', 1, '2') assert result == [1, '2'] - def test_trigger_event_with_catchall_class_namespace(self): + async def test_trigger_event_with_catchall_class_namespace(self): result = {} class MyNamespace(async_namespace.AsyncClientNamespace): @@ -875,18 +852,18 @@ class TestAsyncClient: c = async_client.AsyncClient() c.register_namespace(MyNamespace('*')) - _run(c._trigger_event('connect', '/foo')) + await c._trigger_event('connect', '/foo') assert result['result'] == ('/foo',) - _run(c._trigger_event('foo', '/foo', 'a')) + await c._trigger_event('foo', '/foo', 'a') assert result['result'] == ('/foo', 'a') - _run(c._trigger_event('bar', '/foo')) + await c._trigger_event('bar', '/foo') assert result['result'] == 'bar/foo' - _run(c._trigger_event('baz', '/foo', 'a', 'b')) + await c._trigger_event('baz', '/foo', 'a', 'b') assert result['result'] == ('/foo', 'a', 'b') - _run(c._trigger_event('disconnect', '/foo')) + await c._trigger_event('disconnect', '/foo') assert result['result'] == ('disconnect', '/foo') - def test_trigger_event_unknown_namespace(self): + async def test_trigger_event_unknown_namespace(self): c = async_client.AsyncClient() result = [] @@ -896,7 +873,7 @@ class TestAsyncClient: result.append(b) c.register_namespace(MyNamespace('/')) - _run(c._trigger_event('foo', '/bar', 1, '2')) + await c._trigger_event('foo', '/bar', 1, '2') assert result == [] @mock.patch( @@ -905,13 +882,13 @@ class TestAsyncClient: side_effect=asyncio.TimeoutError, ) @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5]) - def test_handle_reconnect(self, random, wait_for): + async def test_handle_reconnect(self, random, wait_for): c = async_client.AsyncClient() c._reconnect_task = 'foo' c.connect = mock.AsyncMock( side_effect=[ValueError, exceptions.ConnectionError, None] ) - _run(c._handle_reconnect()) + await c._handle_reconnect() assert wait_for.await_count == 3 assert [x[0][1] for x in asyncio.wait_for.await_args_list] == [ 1.5, @@ -926,13 +903,13 @@ class TestAsyncClient: side_effect=asyncio.TimeoutError, ) @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5]) - def test_handle_reconnect_max_delay(self, random, wait_for): + async def test_handle_reconnect_max_delay(self, random, wait_for): c = async_client.AsyncClient(reconnection_delay_max=3) c._reconnect_task = 'foo' c.connect = mock.AsyncMock( side_effect=[ValueError, exceptions.ConnectionError, None] ) - _run(c._handle_reconnect()) + await c._handle_reconnect() assert wait_for.await_count == 3 assert [x[0][1] for x in asyncio.wait_for.await_args_list] == [ 1.5, @@ -947,7 +924,7 @@ class TestAsyncClient: side_effect=asyncio.TimeoutError, ) @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5]) - def test_handle_reconnect_max_attempts(self, random, wait_for): + async def test_handle_reconnect_max_attempts(self, random, wait_for): c = async_client.AsyncClient(reconnection_attempts=2, logger=True) c.connection_namespaces = ['/'] c._reconnect_task = 'foo' @@ -955,7 +932,7 @@ class TestAsyncClient: c.connect = mock.AsyncMock( side_effect=[ValueError, exceptions.ConnectionError, None] ) - _run(c._handle_reconnect()) + await c._handle_reconnect() assert wait_for.await_count == 2 assert [x[0][1] for x in asyncio.wait_for.await_args_list] == [ 1.5, @@ -971,7 +948,7 @@ class TestAsyncClient: side_effect=[asyncio.TimeoutError, None], ) @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5]) - def test_handle_reconnect_aborted(self, random, wait_for): + async def test_handle_reconnect_aborted(self, random, wait_for): c = async_client.AsyncClient(logger=True) c.connection_namespaces = ['/'] c._reconnect_task = 'foo' @@ -979,7 +956,7 @@ class TestAsyncClient: c.connect = mock.AsyncMock( side_effect=[ValueError, exceptions.ConnectionError, None] ) - _run(c._handle_reconnect()) + await c._handle_reconnect() assert wait_for.await_count == 2 assert [x[0][1] for x in asyncio.wait_for.await_args_list] == [ 1.5, @@ -989,7 +966,7 @@ class TestAsyncClient: c._trigger_event.assert_awaited_once_with('__disconnect_final', namespace='/') - def test_shutdown_disconnect(self): + async def test_shutdown_disconnect(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/': '1'} @@ -998,7 +975,7 @@ class TestAsyncClient: c.eio = mock.MagicMock() c.eio.disconnect = mock.AsyncMock() c.eio.state = 'connected' - _run(c.shutdown()) + await c.shutdown() assert c._trigger_event.await_count == 0 assert c._send_packet.await_count == 1 expected_packet = packet.Packet(packet.DISCONNECT, namespace='/') @@ -1008,7 +985,7 @@ class TestAsyncClient: ) c.eio.disconnect.assert_awaited_once_with(abort=True) - def test_shutdown_disconnect_namespaces(self): + async def test_shutdown_disconnect_namespaces(self): c = async_client.AsyncClient() c.connected = True c.namespaces = {'/foo': '1', '/bar': '2'} @@ -1017,7 +994,7 @@ class TestAsyncClient: c.eio = mock.MagicMock() c.eio.disconnect = mock.AsyncMock() c.eio.state = 'connected' - _run(c.shutdown()) + await c.shutdown() assert c._trigger_event.await_count == 0 assert c._send_packet.await_count == 2 expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo') @@ -1032,7 +1009,7 @@ class TestAsyncClient: ) @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5]) - def test_shutdown_reconnect(self, random): + async def test_shutdown_reconnect(self, random): c = async_client.AsyncClient() c.connection_namespaces = ['/'] c._reconnect_task = mock.AsyncMock()() @@ -1045,18 +1022,18 @@ class TestAsyncClient: await c.shutdown() await task - _run(r()) + await r() c._trigger_event.assert_awaited_once_with('__disconnect_final', namespace='/') - def test_handle_eio_connect(self): + async def test_handle_eio_connect(self): c = async_client.AsyncClient() c.connection_namespaces = ['/', '/foo'] c.connection_auth = 'auth' c._send_packet = mock.AsyncMock() c.eio.sid = 'foo' assert c.sid is None - _run(c._handle_eio_connect()) + await c._handle_eio_connect() assert c.sid == 'foo' assert c._send_packet.await_count == 2 expected_packet = packet.Packet( @@ -1072,14 +1049,14 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_eio_connect_function(self): + async def test_handle_eio_connect_function(self): c = async_client.AsyncClient() c.connection_namespaces = ['/', '/foo'] c.connection_auth = lambda: 'auth' c._send_packet = mock.AsyncMock() c.eio.sid = 'foo' assert c.sid is None - _run(c._handle_eio_connect()) + await c._handle_eio_connect() assert c.sid == 'foo' assert c._send_packet.await_count == 2 expected_packet = packet.Packet( @@ -1095,7 +1072,7 @@ class TestAsyncClient: == expected_packet.encode() ) - def test_handle_eio_message(self): + async def test_handle_eio_message(self): c = async_client.AsyncClient() c._handle_connect = mock.AsyncMock() c._handle_disconnect = mock.AsyncMock() @@ -1103,48 +1080,46 @@ class TestAsyncClient: c._handle_ack = mock.AsyncMock() c._handle_error = mock.AsyncMock() - _run(c._handle_eio_message('0{"sid":"123"}')) + await c._handle_eio_message('0{"sid":"123"}') c._handle_connect.assert_awaited_with(None, {'sid': '123'}) - _run(c._handle_eio_message('0/foo,{"sid":"123"}')) + await c._handle_eio_message('0/foo,{"sid":"123"}') c._handle_connect.assert_awaited_with('/foo', {'sid': '123'}) - _run(c._handle_eio_message('1')) + await c._handle_eio_message('1') c._handle_disconnect.assert_awaited_with(None) - _run(c._handle_eio_message('1/foo')) + await c._handle_eio_message('1/foo') c._handle_disconnect.assert_awaited_with('/foo') - _run(c._handle_eio_message('2["foo"]')) + await c._handle_eio_message('2["foo"]') c._handle_event.assert_awaited_with(None, None, ['foo']) - _run(c._handle_eio_message('3/foo,["bar"]')) + await c._handle_eio_message('3/foo,["bar"]') c._handle_ack.assert_awaited_with('/foo', None, ['bar']) - _run(c._handle_eio_message('4')) + await c._handle_eio_message('4') c._handle_error.assert_awaited_with(None, None) - _run(c._handle_eio_message('4"foo"')) + await c._handle_eio_message('4"foo"') c._handle_error.assert_awaited_with(None, 'foo') - _run(c._handle_eio_message('4["foo"]')) + await c._handle_eio_message('4["foo"]') c._handle_error.assert_awaited_with(None, ['foo']) - _run(c._handle_eio_message('4/foo')) + await c._handle_eio_message('4/foo') c._handle_error.assert_awaited_with('/foo', None) - _run(c._handle_eio_message('4/foo,["foo","bar"]')) + await c._handle_eio_message('4/foo,["foo","bar"]') c._handle_error.assert_awaited_with('/foo', ['foo', 'bar']) - _run(c._handle_eio_message('51-{"_placeholder":true,"num":0}')) + await c._handle_eio_message('51-{"_placeholder":true,"num":0}') assert c._binary_packet.packet_type == packet.BINARY_EVENT - _run(c._handle_eio_message(b'foo')) + await c._handle_eio_message(b'foo') c._handle_event.assert_awaited_with(None, None, b'foo') - _run( - c._handle_eio_message( - '62-/foo,{"1":{"_placeholder":true,"num":1},' - '"2":{"_placeholder":true,"num":0}}' - ) + await c._handle_eio_message( + '62-/foo,{"1":{"_placeholder":true,"num":1},' + '"2":{"_placeholder":true,"num":0}}' ) assert c._binary_packet.packet_type == packet.BINARY_ACK - _run(c._handle_eio_message(b'bar')) - _run(c._handle_eio_message(b'foo')) + await c._handle_eio_message(b'bar') + await c._handle_eio_message(b'foo') c._handle_ack.assert_awaited_with( '/foo', None, {'1': b'foo', '2': b'bar'} ) with pytest.raises(ValueError): - _run(c._handle_eio_message('9')) + await c._handle_eio_message('9') - def test_eio_disconnect(self): + async def test_eio_disconnect(self): c = async_client.AsyncClient() c.namespaces = {'/': '1'} c.connected = True @@ -1152,41 +1127,41 @@ class TestAsyncClient: c.start_background_task = mock.MagicMock() c.sid = 'foo' c.eio.state = 'connected' - _run(c._handle_eio_disconnect()) + await c._handle_eio_disconnect() c._trigger_event.assert_awaited_once_with( 'disconnect', namespace='/' ) assert c.sid is None assert not c.connected - def test_eio_disconnect_namespaces(self): + async def test_eio_disconnect_namespaces(self): c = async_client.AsyncClient(reconnection=False) c.namespaces = {'/foo': '1', '/bar': '2'} c.connected = True c._trigger_event = mock.AsyncMock() c.sid = 'foo' c.eio.state = 'connected' - _run(c._handle_eio_disconnect()) + await c._handle_eio_disconnect() c._trigger_event.assert_any_await('disconnect', namespace='/foo') c._trigger_event.assert_any_await('disconnect', namespace='/bar') assert c.sid is None assert not c.connected - def test_eio_disconnect_reconnect(self): + async def test_eio_disconnect_reconnect(self): c = async_client.AsyncClient(reconnection=True) c.start_background_task = mock.MagicMock() c.eio.state = 'connected' - _run(c._handle_eio_disconnect()) + await c._handle_eio_disconnect() c.start_background_task.assert_called_once_with(c._handle_reconnect) - def test_eio_disconnect_self_disconnect(self): + async def test_eio_disconnect_self_disconnect(self): c = async_client.AsyncClient(reconnection=True) c.start_background_task = mock.MagicMock() c.eio.state = 'disconnected' - _run(c._handle_eio_disconnect()) + await c._handle_eio_disconnect() c.start_background_task.assert_not_called() - def test_eio_disconnect_no_reconnect(self): + async def test_eio_disconnect_no_reconnect(self): c = async_client.AsyncClient(reconnection=False) c.namespaces = {'/': '1'} c.connected = True @@ -1194,7 +1169,7 @@ class TestAsyncClient: c.start_background_task = mock.MagicMock() c.sid = 'foo' c.eio.state = 'connected' - _run(c._handle_eio_disconnect()) + await c._handle_eio_disconnect() c._trigger_event.assert_any_await( 'disconnect', namespace='/' ) diff --git a/tests/async/test_manager.py b/tests/async/test_manager.py index 77b9bdb..fd5fe81 100644 --- a/tests/async/test_manager.py +++ b/tests/async/test_manager.py @@ -2,7 +2,6 @@ from unittest import mock from socketio import async_manager from socketio import packet -from .helpers import _run class TestAsyncManager: @@ -23,8 +22,8 @@ class TestAsyncManager: self.bm.set_server(mock_server) self.bm.initialize() - def test_connect(self): - sid = _run(self.bm.connect('123', '/foo')) + async def test_connect(self): + sid = await self.bm.connect('123', '/foo') assert None in self.bm.rooms['/foo'] assert sid in self.bm.rooms['/foo'] assert sid in self.bm.rooms['/foo'][None] @@ -33,9 +32,9 @@ class TestAsyncManager: assert dict(self.bm.rooms['/foo'][sid]) == {sid: '123'} assert self.bm.sid_from_eio_sid('123', '/foo') == sid - def test_pre_disconnect(self): - sid1 = _run(self.bm.connect('123', '/foo')) - sid2 = _run(self.bm.connect('456', '/foo')) + async def test_pre_disconnect(self): + sid1 = await self.bm.connect('123', '/foo') + sid2 = await self.bm.connect('456', '/foo') assert self.bm.is_connected(sid1, '/foo') assert self.bm.pre_disconnect(sid1, '/foo') == '123' assert self.bm.pending_disconnect == {'/foo': [sid1]} @@ -43,124 +42,124 @@ class TestAsyncManager: assert self.bm.pre_disconnect(sid2, '/foo') == '456' assert self.bm.pending_disconnect == {'/foo': [sid1, sid2]} assert not self.bm.is_connected(sid2, '/foo') - _run(self.bm.disconnect(sid1, '/foo')) + await self.bm.disconnect(sid1, '/foo') assert self.bm.pending_disconnect == {'/foo': [sid2]} - _run(self.bm.disconnect(sid2, '/foo')) + await self.bm.disconnect(sid2, '/foo') assert self.bm.pending_disconnect == {} - def test_disconnect(self): - sid1 = _run(self.bm.connect('123', '/foo')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - _run(self.bm.enter_room(sid2, '/foo', 'baz')) - _run(self.bm.disconnect(sid1, '/foo')) + async def test_disconnect(self): + sid1 = await self.bm.connect('123', '/foo') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + await self.bm.enter_room(sid2, '/foo', 'baz') + await self.bm.disconnect(sid1, '/foo') assert dict(self.bm.rooms['/foo'][None]) == {sid2: '456'} assert dict(self.bm.rooms['/foo'][sid2]) == {sid2: '456'} assert dict(self.bm.rooms['/foo']['baz']) == {sid2: '456'} - def test_disconnect_default_namespace(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('123', '/foo')) - sid3 = _run(self.bm.connect('456', '/')) - sid4 = _run(self.bm.connect('456', '/foo')) + async def test_disconnect_default_namespace(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('123', '/foo') + sid3 = await self.bm.connect('456', '/') + sid4 = await self.bm.connect('456', '/foo') assert self.bm.is_connected(sid1, '/') assert self.bm.is_connected(sid2, '/foo') assert not self.bm.is_connected(sid2, '/') assert not self.bm.is_connected(sid1, '/foo') - _run(self.bm.disconnect(sid1, '/')) + await self.bm.disconnect(sid1, '/') assert not self.bm.is_connected(sid1, '/') assert self.bm.is_connected(sid2, '/foo') - _run(self.bm.disconnect(sid2, '/foo')) + await self.bm.disconnect(sid2, '/foo') assert not self.bm.is_connected(sid2, '/foo') assert dict(self.bm.rooms['/'][None]) == {sid3: '456'} assert dict(self.bm.rooms['/'][sid3]) == {sid3: '456'} assert dict(self.bm.rooms['/foo'][None]) == {sid4: '456'} assert dict(self.bm.rooms['/foo'][sid4]) == {sid4: '456'} - def test_disconnect_twice(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('123', '/foo')) - sid3 = _run(self.bm.connect('456', '/')) - sid4 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.disconnect(sid1, '/')) - _run(self.bm.disconnect(sid2, '/foo')) - _run(self.bm.disconnect(sid1, '/')) - _run(self.bm.disconnect(sid2, '/foo')) + async def test_disconnect_twice(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('123', '/foo') + sid3 = await self.bm.connect('456', '/') + sid4 = await self.bm.connect('456', '/foo') + await self.bm.disconnect(sid1, '/') + await self.bm.disconnect(sid2, '/foo') + await self.bm.disconnect(sid1, '/') + await self.bm.disconnect(sid2, '/foo') assert dict(self.bm.rooms['/'][None]) == {sid3: '456'} assert dict(self.bm.rooms['/'][sid3]) == {sid3: '456'} assert dict(self.bm.rooms['/foo'][None]) == {sid4: '456'} assert dict(self.bm.rooms['/foo'][sid4]) == {sid4: '456'} - def test_disconnect_all(self): - sid1 = _run(self.bm.connect('123', '/foo')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - _run(self.bm.enter_room(sid2, '/foo', 'baz')) - _run(self.bm.disconnect(sid1, '/foo')) - _run(self.bm.disconnect(sid2, '/foo')) + async def test_disconnect_all(self): + sid1 = await self.bm.connect('123', '/foo') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + await self.bm.enter_room(sid2, '/foo', 'baz') + await self.bm.disconnect(sid1, '/foo') + await self.bm.disconnect(sid2, '/foo') assert self.bm.rooms == {} - def test_disconnect_with_callbacks(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('123', '/foo')) - sid3 = _run(self.bm.connect('456', '/foo')) + async def test_disconnect_with_callbacks(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('123', '/foo') + sid3 = await self.bm.connect('456', '/foo') self.bm._generate_ack_id(sid1, 'f') self.bm._generate_ack_id(sid2, 'g') self.bm._generate_ack_id(sid3, 'h') - _run(self.bm.disconnect(sid2, '/foo')) + await self.bm.disconnect(sid2, '/foo') assert sid2 not in self.bm.callbacks - _run(self.bm.disconnect(sid1, '/')) + await self.bm.disconnect(sid1, '/') assert sid1 not in self.bm.callbacks assert sid3 in self.bm.callbacks - def test_trigger_sync_callback(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('123', '/foo')) + async def test_trigger_sync_callback(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('123', '/foo') cb = mock.MagicMock() id1 = self.bm._generate_ack_id(sid1, cb) id2 = self.bm._generate_ack_id(sid2, cb) - _run(self.bm.trigger_callback(sid1, id1, ['foo'])) - _run(self.bm.trigger_callback(sid2, id2, ['bar', 'baz'])) + await self.bm.trigger_callback(sid1, id1, ['foo']) + await self.bm.trigger_callback(sid2, id2, ['bar', 'baz']) assert cb.call_count == 2 cb.assert_any_call('foo') cb.assert_any_call('bar', 'baz') - def test_trigger_async_callback(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('123', '/foo')) + async def test_trigger_async_callback(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('123', '/foo') cb = mock.AsyncMock() id1 = self.bm._generate_ack_id(sid1, cb) id2 = self.bm._generate_ack_id(sid2, cb) - _run(self.bm.trigger_callback(sid1, id1, ['foo'])) - _run(self.bm.trigger_callback(sid2, id2, ['bar', 'baz'])) + await self.bm.trigger_callback(sid1, id1, ['foo']) + await self.bm.trigger_callback(sid2, id2, ['bar', 'baz']) assert cb.await_count == 2 cb.assert_any_await('foo') cb.assert_any_await('bar', 'baz') - def test_invalid_callback(self): - sid = _run(self.bm.connect('123', '/')) + async def test_invalid_callback(self): + sid = await self.bm.connect('123', '/') cb = mock.MagicMock() id = self.bm._generate_ack_id(sid, cb) # these should not raise an exception - _run(self.bm.trigger_callback('xxx', id, ['foo'])) - _run(self.bm.trigger_callback(sid, id + 1, ['foo'])) + await self.bm.trigger_callback('xxx', id, ['foo']) + await self.bm.trigger_callback(sid, id + 1, ['foo']) assert cb.call_count == 0 - def test_get_namespaces(self): + async def test_get_namespaces(self): assert list(self.bm.get_namespaces()) == [] - _run(self.bm.connect('123', '/')) - _run(self.bm.connect('123', '/foo')) + await self.bm.connect('123', '/') + await self.bm.connect('123', '/foo') namespaces = list(self.bm.get_namespaces()) assert len(namespaces) == 2 assert '/' in namespaces assert '/foo' in namespaces - def test_get_participants(self): - sid1 = _run(self.bm.connect('123', '/')) - sid2 = _run(self.bm.connect('456', '/')) - sid3 = _run(self.bm.connect('789', '/')) - _run(self.bm.disconnect(sid3, '/')) + async def test_get_participants(self): + sid1 = await self.bm.connect('123', '/') + sid2 = await self.bm.connect('456', '/') + sid3 = await self.bm.connect('789', '/') + await self.bm.disconnect(sid3, '/') assert sid3 not in self.bm.rooms['/'][None] participants = list(self.bm.get_participants('/', None)) assert len(participants) == 2 @@ -168,44 +167,42 @@ class TestAsyncManager: assert (sid2, '456') in participants assert (sid3, '789') not in participants - def test_leave_invalid_room(self): - sid = _run(self.bm.connect('123', '/foo')) - _run(self.bm.leave_room(sid, '/foo', 'baz')) - _run(self.bm.leave_room(sid, '/bar', 'baz')) + async def test_leave_invalid_room(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.leave_room(sid, '/foo', 'baz') + await self.bm.leave_room(sid, '/bar', 'baz') - def test_no_room(self): + async def test_no_room(self): rooms = self.bm.get_rooms('123', '/foo') assert [] == rooms - def test_close_room(self): - sid = _run(self.bm.connect('123', '/foo')) - _run(self.bm.connect('456', '/foo')) - _run(self.bm.connect('789', '/foo')) - _run(self.bm.enter_room(sid, '/foo', 'bar')) - _run(self.bm.enter_room(sid, '/foo', 'bar')) - _run(self.bm.close_room('bar', '/foo')) + async def test_close_room(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.connect('456', '/foo') + await self.bm.connect('789', '/foo') + await self.bm.enter_room(sid, '/foo', 'bar') + await self.bm.enter_room(sid, '/foo', 'bar') + await self.bm.close_room('bar', '/foo') from pprint import pprint pprint(self.bm.rooms) assert 'bar' not in self.bm.rooms['/foo'] - def test_close_invalid_room(self): + async def test_close_invalid_room(self): self.bm.close_room('bar', '/foo') - def test_rooms(self): - sid = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid, '/foo', 'bar')) + async def test_rooms(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid, '/foo', 'bar') r = self.bm.get_rooms(sid, '/foo') assert len(r) == 2 assert sid in r assert 'bar' in r - def test_emit_to_sid(self): - sid = _run(self.bm.connect('123', '/foo')) - _run(self.bm.connect('456', '/foo')) - _run( - self.bm.emit( - 'my event', {'foo': 'bar'}, namespace='/foo', to=sid - ) + async def test_emit_to_sid(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.connect('456', '/foo') + await self.bm.emit( + 'my event', {'foo': 'bar'}, namespace='/foo', to=sid ) assert self.bm.server._send_eio_packet.await_count == 1 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -213,16 +210,14 @@ class TestAsyncManager: pkt = self.bm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_to_room(self): - sid1 = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid2, '/foo', 'bar')) - _run(self.bm.connect('789', '/foo')) - _run( - self.bm.emit( - 'my event', {'foo': 'bar'}, namespace='/foo', room='bar' - ) + async def test_emit_to_room(self): + sid1 = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid2, '/foo', 'bar') + await self.bm.connect('789', '/foo') + await self.bm.emit( + 'my event', {'foo': 'bar'}, namespace='/foo', room='bar' ) assert self.bm.server._send_eio_packet.await_count == 2 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -234,18 +229,16 @@ class TestAsyncManager: == pkt assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_to_rooms(self): - sid1 = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid2, '/foo', 'bar')) - _run(self.bm.enter_room(sid2, '/foo', 'baz')) - sid3 = _run(self.bm.connect('789', '/foo')) - _run(self.bm.enter_room(sid3, '/foo', 'baz')) - _run( - self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo', - room=['bar', 'baz']) - ) + async def test_emit_to_rooms(self): + sid1 = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid2, '/foo', 'bar') + await self.bm.enter_room(sid2, '/foo', 'baz') + sid3 = await self.bm.connect('789', '/foo') + await self.bm.enter_room(sid3, '/foo', 'baz') + await self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo', + room=['bar', 'baz']) assert self.bm.server._send_eio_packet.await_count == 3 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ == '123' @@ -260,14 +253,14 @@ class TestAsyncManager: == pkt assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_to_all(self): - sid1 = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid2, '/foo', 'bar')) - _run(self.bm.connect('789', '/foo')) - _run(self.bm.connect('abc', '/bar')) - _run(self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo')) + async def test_emit_to_all(self): + sid1 = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid2, '/foo', 'bar') + await self.bm.connect('789', '/foo') + await self.bm.connect('abc', '/bar') + await self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo') assert self.bm.server._send_eio_packet.await_count == 3 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ == '123' @@ -282,17 +275,15 @@ class TestAsyncManager: == pkt assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_to_all_skip_one(self): - sid1 = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid2, '/foo', 'bar')) - _run(self.bm.connect('789', '/foo')) - _run(self.bm.connect('abc', '/bar')) - _run( - self.bm.emit( - 'my event', {'foo': 'bar'}, namespace='/foo', skip_sid=sid2 - ) + async def test_emit_to_all_skip_one(self): + sid1 = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid2, '/foo', 'bar') + await self.bm.connect('789', '/foo') + await self.bm.connect('abc', '/bar') + await self.bm.emit( + 'my event', {'foo': 'bar'}, namespace='/foo', skip_sid=sid2 ) assert self.bm.server._send_eio_packet.await_count == 2 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -304,20 +295,18 @@ class TestAsyncManager: == pkt assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_to_all_skip_two(self): - sid1 = _run(self.bm.connect('123', '/foo')) - _run(self.bm.enter_room(sid1, '/foo', 'bar')) - sid2 = _run(self.bm.connect('456', '/foo')) - _run(self.bm.enter_room(sid2, '/foo', 'bar')) - sid3 = _run(self.bm.connect('789', '/foo')) - _run(self.bm.connect('abc', '/bar')) - _run( - self.bm.emit( - 'my event', - {'foo': 'bar'}, - namespace='/foo', - skip_sid=[sid1, sid3], - ) + async def test_emit_to_all_skip_two(self): + sid1 = await self.bm.connect('123', '/foo') + await self.bm.enter_room(sid1, '/foo', 'bar') + sid2 = await self.bm.connect('456', '/foo') + await self.bm.enter_room(sid2, '/foo', 'bar') + sid3 = await self.bm.connect('789', '/foo') + await self.bm.connect('abc', '/bar') + await self.bm.emit( + 'my event', + {'foo': 'bar'}, + namespace='/foo', + skip_sid=[sid1, sid3], ) assert self.bm.server._send_eio_packet.await_count == 1 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -325,14 +314,12 @@ class TestAsyncManager: pkt = self.bm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42/foo,["my event",{"foo":"bar"}]' - def test_emit_with_callback(self): - sid = _run(self.bm.connect('123', '/foo')) + async def test_emit_with_callback(self): + sid = await self.bm.connect('123', '/foo') self.bm._generate_ack_id = mock.MagicMock() self.bm._generate_ack_id.return_value = 11 - _run( - self.bm.emit( - 'my event', {'foo': 'bar'}, namespace='/foo', callback='cb' - ) + await self.bm.emit( + 'my event', {'foo': 'bar'}, namespace='/foo', callback='cb' ) self.bm._generate_ack_id.assert_called_once_with(sid, 'cb') assert self.bm.server._send_packet.await_count == 1 @@ -341,20 +328,17 @@ class TestAsyncManager: pkt = self.bm.server._send_packet.await_args_list[0][0][1] assert pkt.encode() == '2/foo,11["my event",{"foo":"bar"}]' - def test_emit_to_invalid_room(self): - _run( - self.bm.emit('my event', {'foo': 'bar'}, namespace='/', room='123') - ) + async def test_emit_to_invalid_room(self): + await self.bm.emit('my event', {'foo': 'bar'}, namespace='/', + room='123') - def test_emit_to_invalid_namespace(self): - _run(self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo')) + async def test_emit_to_invalid_namespace(self): + await self.bm.emit('my event', {'foo': 'bar'}, namespace='/foo') - def test_emit_with_tuple(self): - sid = _run(self.bm.connect('123', '/foo')) - _run( - self.bm.emit( - 'my event', ('foo', 'bar'), namespace='/foo', room=sid - ) + async def test_emit_with_tuple(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.emit( + 'my event', ('foo', 'bar'), namespace='/foo', room=sid ) assert self.bm.server._send_eio_packet.await_count == 1 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -362,12 +346,10 @@ class TestAsyncManager: pkt = self.bm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42/foo,["my event","foo","bar"]' - def test_emit_with_list(self): - sid = _run(self.bm.connect('123', '/foo')) - _run( - self.bm.emit( - 'my event', ['foo', 'bar'], namespace='/foo', room=sid - ) + async def test_emit_with_list(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.emit( + 'my event', ['foo', 'bar'], namespace='/foo', room=sid ) assert self.bm.server._send_eio_packet.await_count == 1 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -375,12 +357,10 @@ class TestAsyncManager: pkt = self.bm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42/foo,["my event",["foo","bar"]]' - def test_emit_with_none(self): - sid = _run(self.bm.connect('123', '/foo')) - _run( - self.bm.emit( - 'my event', None, namespace='/foo', room=sid - ) + async def test_emit_with_none(self): + sid = await self.bm.connect('123', '/foo') + await self.bm.emit( + 'my event', None, namespace='/foo', room=sid ) assert self.bm.server._send_eio_packet.await_count == 1 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ @@ -388,12 +368,10 @@ class TestAsyncManager: pkt = self.bm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42/foo,["my event"]' - def test_emit_binary(self): - sid = _run(self.bm.connect('123', '/')) - _run( - self.bm.emit( - 'my event', b'my binary data', namespace='/', room=sid - ) + async def test_emit_binary(self): + sid = await self.bm.connect('123', '/') + await self.bm.emit( + 'my event', b'my binary data', namespace='/', room=sid ) assert self.bm.server._send_eio_packet.await_count == 2 assert self.bm.server._send_eio_packet.await_args_list[0][0][0] \ diff --git a/tests/async/test_namespace.py b/tests/async/test_namespace.py index 6256015..ad9b1a0 100644 --- a/tests/async/test_namespace.py +++ b/tests/async/test_namespace.py @@ -1,11 +1,10 @@ from unittest import mock from socketio import async_namespace -from .helpers import _run class TestAsyncNamespace: - def test_connect_event(self): + async def test_connect_event(self): result = {} class MyNamespace(async_namespace.AsyncNamespace): @@ -14,10 +13,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_server(mock.MagicMock()) - _run(ns.trigger_event('connect', 'sid', {'foo': 'bar'})) + await ns.trigger_event('connect', 'sid', {'foo': 'bar'}) assert result['result'] == ('sid', {'foo': 'bar'}) - def test_disconnect_event(self): + async def test_disconnect_event(self): result = {} class MyNamespace(async_namespace.AsyncNamespace): @@ -26,10 +25,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_server(mock.MagicMock()) - _run(ns.trigger_event('disconnect', 'sid')) + await ns.trigger_event('disconnect', 'sid') assert result['result'] == 'sid' - def test_sync_event(self): + async def test_sync_event(self): result = {} class MyNamespace(async_namespace.AsyncNamespace): @@ -38,10 +37,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_server(mock.MagicMock()) - _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'})) + await ns.trigger_event('custom_message', 'sid', {'data': 'data'}) assert result['result'] == ('sid', {'data': 'data'}) - def test_async_event(self): + async def test_async_event(self): result = {} class MyNamespace(async_namespace.AsyncNamespace): @@ -50,10 +49,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_server(mock.MagicMock()) - _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'})) + await ns.trigger_event('custom_message', 'sid', {'data': 'data'}) assert result['result'] == ('sid', {'data': 'data'}) - def test_event_not_found(self): + async def test_event_not_found(self): result = {} class MyNamespace(async_namespace.AsyncNamespace): @@ -62,20 +61,17 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_server(mock.MagicMock()) - _run( - ns.trigger_event('another_custom_message', 'sid', {'data': 'data'}) - ) + await ns.trigger_event('another_custom_message', 'sid', + {'data': 'data'}) assert result == {} - def test_emit(self): + async def test_emit(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.emit = mock.AsyncMock() ns._set_server(mock_server) - _run( - ns.emit( - 'ev', data='data', to='room', skip_sid='skip', callback='cb' - ) + await ns.emit( + 'ev', data='data', to='room', skip_sid='skip', callback='cb' ) ns.server.emit.assert_awaited_with( 'ev', @@ -87,16 +83,14 @@ class TestAsyncNamespace: callback='cb', ignore_queue=False, ) - _run( - ns.emit( - 'ev', - data='data', - room='room', - skip_sid='skip', - namespace='/bar', - callback='cb', - ignore_queue=True, - ) + await ns.emit( + 'ev', + data='data', + room='room', + skip_sid='skip', + namespace='/bar', + callback='cb', + ignore_queue=True, ) ns.server.emit.assert_awaited_with( 'ev', @@ -109,12 +103,12 @@ class TestAsyncNamespace: ignore_queue=True, ) - def test_send(self): + async def test_send(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.send = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.send(data='data', to='room', skip_sid='skip', callback='cb')) + await ns.send(data='data', to='room', skip_sid='skip', callback='cb') ns.server.send.assert_awaited_with( 'data', to='room', @@ -124,15 +118,13 @@ class TestAsyncNamespace: callback='cb', ignore_queue=False, ) - _run( - ns.send( - data='data', - room='room', - skip_sid='skip', - namespace='/bar', - callback='cb', - ignore_queue=True, - ) + await ns.send( + data='data', + room='room', + skip_sid='skip', + namespace='/bar', + callback='cb', + ignore_queue=True, ) ns.server.send.assert_awaited_with( 'data', @@ -144,12 +136,12 @@ class TestAsyncNamespace: ignore_queue=True, ) - def test_call(self): + async def test_call(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.call = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.call('ev', data='data', to='sid')) + await ns.call('ev', data='data', to='sid') ns.server.call.assert_awaited_with( 'ev', data='data', @@ -159,8 +151,8 @@ class TestAsyncNamespace: timeout=None, ignore_queue=False, ) - _run(ns.call('ev', data='data', sid='sid', namespace='/bar', - timeout=45, ignore_queue=True)) + await ns.call('ev', data='data', sid='sid', namespace='/bar', + timeout=45, ignore_queue=True) ns.server.call.assert_awaited_with( 'ev', data='data', @@ -171,45 +163,45 @@ class TestAsyncNamespace: ignore_queue=True, ) - def test_enter_room(self): + async def test_enter_room(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.enter_room = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.enter_room('sid', 'room')) + await ns.enter_room('sid', 'room') ns.server.enter_room.assert_awaited_with( 'sid', 'room', namespace='/foo' ) - _run(ns.enter_room('sid', 'room', namespace='/bar')) + await ns.enter_room('sid', 'room', namespace='/bar') ns.server.enter_room.assert_awaited_with( 'sid', 'room', namespace='/bar' ) - def test_leave_room(self): + async def test_leave_room(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.leave_room = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.leave_room('sid', 'room')) + await ns.leave_room('sid', 'room') ns.server.leave_room.assert_awaited_with( 'sid', 'room', namespace='/foo' ) - _run(ns.leave_room('sid', 'room', namespace='/bar')) + await ns.leave_room('sid', 'room', namespace='/bar') ns.server.leave_room.assert_awaited_with( 'sid', 'room', namespace='/bar' ) - def test_close_room(self): + async def test_close_room(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.close_room = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.close_room('room')) + await ns.close_room('room') ns.server.close_room.assert_awaited_with('room', namespace='/foo') - _run(ns.close_room('room', namespace='/bar')) + await ns.close_room('room', namespace='/bar') ns.server.close_room.assert_awaited_with('room', namespace='/bar') - def test_rooms(self): + async def test_rooms(self): ns = async_namespace.AsyncNamespace('/foo') ns._set_server(mock.MagicMock()) ns.rooms('sid') @@ -217,21 +209,21 @@ class TestAsyncNamespace: ns.rooms('sid', namespace='/bar') ns.server.rooms.assert_called_with('sid', namespace='/bar') - def test_session(self): + async def test_session(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.get_session = mock.AsyncMock() mock_server.save_session = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.get_session('sid')) + await ns.get_session('sid') ns.server.get_session.assert_awaited_with('sid', namespace='/foo') - _run(ns.get_session('sid', namespace='/bar')) + await ns.get_session('sid', namespace='/bar') ns.server.get_session.assert_awaited_with('sid', namespace='/bar') - _run(ns.save_session('sid', {'a': 'b'})) + await ns.save_session('sid', {'a': 'b'}) ns.server.save_session.assert_awaited_with( 'sid', {'a': 'b'}, namespace='/foo' ) - _run(ns.save_session('sid', {'a': 'b'}, namespace='/bar')) + await ns.save_session('sid', {'a': 'b'}, namespace='/bar') ns.server.save_session.assert_awaited_with( 'sid', {'a': 'b'}, namespace='/bar' ) @@ -240,17 +232,17 @@ class TestAsyncNamespace: ns.session('sid', namespace='/bar') ns.server.session.assert_called_with('sid', namespace='/bar') - def test_disconnect(self): + async def test_disconnect(self): ns = async_namespace.AsyncNamespace('/foo') mock_server = mock.MagicMock() mock_server.disconnect = mock.AsyncMock() ns._set_server(mock_server) - _run(ns.disconnect('sid')) + await ns.disconnect('sid') ns.server.disconnect.assert_awaited_with('sid', namespace='/foo') - _run(ns.disconnect('sid', namespace='/bar')) + await ns.disconnect('sid', namespace='/bar') ns.server.disconnect.assert_awaited_with('sid', namespace='/bar') - def test_sync_event_client(self): + async def test_sync_event_client(self): result = {} class MyNamespace(async_namespace.AsyncClientNamespace): @@ -259,10 +251,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_client(mock.MagicMock()) - _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'})) + await ns.trigger_event('custom_message', 'sid', {'data': 'data'}) assert result['result'] == ('sid', {'data': 'data'}) - def test_async_event_client(self): + async def test_async_event_client(self): result = {} class MyNamespace(async_namespace.AsyncClientNamespace): @@ -271,10 +263,10 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_client(mock.MagicMock()) - _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'})) + await ns.trigger_event('custom_message', 'sid', {'data': 'data'}) assert result['result'] == ('sid', {'data': 'data'}) - def test_event_not_found_client(self): + async def test_event_not_found_client(self): result = {} class MyNamespace(async_namespace.AsyncClientNamespace): @@ -283,57 +275,56 @@ class TestAsyncNamespace: ns = MyNamespace('/foo') ns._set_client(mock.MagicMock()) - _run( - ns.trigger_event('another_custom_message', 'sid', {'data': 'data'}) - ) + await ns.trigger_event('another_custom_message', 'sid', + {'data': 'data'}) assert result == {} - def test_emit_client(self): + async def test_emit_client(self): ns = async_namespace.AsyncClientNamespace('/foo') mock_client = mock.MagicMock() mock_client.emit = mock.AsyncMock() ns._set_client(mock_client) - _run(ns.emit('ev', data='data', callback='cb')) + await ns.emit('ev', data='data', callback='cb') ns.client.emit.assert_awaited_with( 'ev', data='data', namespace='/foo', callback='cb' ) - _run(ns.emit('ev', data='data', namespace='/bar', callback='cb')) + await ns.emit('ev', data='data', namespace='/bar', callback='cb') ns.client.emit.assert_awaited_with( 'ev', data='data', namespace='/bar', callback='cb' ) - def test_send_client(self): + async def test_send_client(self): ns = async_namespace.AsyncClientNamespace('/foo') mock_client = mock.MagicMock() mock_client.send = mock.AsyncMock() ns._set_client(mock_client) - _run(ns.send(data='data', callback='cb')) + await ns.send(data='data', callback='cb') ns.client.send.assert_awaited_with( 'data', namespace='/foo', callback='cb' ) - _run(ns.send(data='data', namespace='/bar', callback='cb')) + await ns.send(data='data', namespace='/bar', callback='cb') ns.client.send.assert_awaited_with( 'data', namespace='/bar', callback='cb' ) - def test_call_client(self): + async def test_call_client(self): ns = async_namespace.AsyncClientNamespace('/foo') mock_client = mock.MagicMock() mock_client.call = mock.AsyncMock() ns._set_client(mock_client) - _run(ns.call('ev', data='data')) + await ns.call('ev', data='data') ns.client.call.assert_awaited_with( 'ev', data='data', namespace='/foo', timeout=None ) - _run(ns.call('ev', data='data', namespace='/bar', timeout=45)) + await ns.call('ev', data='data', namespace='/bar', timeout=45) ns.client.call.assert_awaited_with( 'ev', data='data', namespace='/bar', timeout=45 ) - def test_disconnect_client(self): + async def test_disconnect_client(self): ns = async_namespace.AsyncClientNamespace('/foo') mock_client = mock.MagicMock() mock_client.disconnect = mock.AsyncMock() ns._set_client(mock_client) - _run(ns.disconnect()) + await ns.disconnect() ns.client.disconnect.assert_awaited_with() diff --git a/tests/async/test_pubsub_manager.py b/tests/async/test_pubsub_manager.py index 4692882..71d948a 100644 --- a/tests/async/test_pubsub_manager.py +++ b/tests/async/test_pubsub_manager.py @@ -7,7 +7,6 @@ import pytest from socketio import async_manager from socketio import async_pubsub_manager from socketio import packet -from .helpers import _run class TestAsyncPubSubManager: @@ -31,18 +30,18 @@ class TestAsyncPubSubManager: self.pm.host_id = '123456' self.pm.initialize() - def test_default_init(self): + async def test_default_init(self): assert self.pm.channel == 'socketio' self.pm.server.start_background_task.assert_called_once_with( self.pm._thread ) - def test_custom_init(self): + async def test_custom_init(self): pubsub = async_pubsub_manager.AsyncPubSubManager(channel='foo') assert pubsub.channel == 'foo' assert len(pubsub.host_id) == 32 - def test_write_only_init(self): + async def test_write_only_init(self): mock_server = mock.MagicMock() pm = async_pubsub_manager.AsyncPubSubManager(write_only=True) pm.set_server(mock_server) @@ -51,8 +50,8 @@ class TestAsyncPubSubManager: assert len(pm.host_id) == 32 assert pm.server.start_background_task.call_count == 0 - def test_emit(self): - _run(self.pm.emit('foo', 'bar')) + async def test_emit(self): + await self.pm.emit('foo', 'bar') self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -66,9 +65,9 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_to(self): + async def test_emit_with_to(self): sid = 'room-mate' - _run(self.pm.emit('foo', 'bar', to=sid)) + await self.pm.emit('foo', 'bar', to=sid) self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -82,8 +81,8 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_namespace(self): - _run(self.pm.emit('foo', 'bar', namespace='/baz')) + async def test_emit_with_namespace(self): + await self.pm.emit('foo', 'bar', namespace='/baz') self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -97,8 +96,8 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_room(self): - _run(self.pm.emit('foo', 'bar', room='baz')) + async def test_emit_with_room(self): + await self.pm.emit('foo', 'bar', room='baz') self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -112,8 +111,8 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_skip_sid(self): - _run(self.pm.emit('foo', 'bar', skip_sid='baz')) + async def test_emit_with_skip_sid(self): + await self.pm.emit('foo', 'bar', skip_sid='baz') self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -127,11 +126,11 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_callback(self): + async def test_emit_with_callback(self): with mock.patch.object( self.pm, '_generate_ack_id', return_value='123' ): - _run(self.pm.emit('foo', 'bar', room='baz', callback='cb')) + await self.pm.emit('foo', 'bar', room='baz', callback='cb') self.pm._publish.assert_awaited_once_with( { 'method': 'emit', @@ -145,24 +144,22 @@ class TestAsyncPubSubManager: } ) - def test_emit_with_callback_without_server(self): + async def test_emit_with_callback_without_server(self): standalone_pm = async_pubsub_manager.AsyncPubSubManager() with pytest.raises(RuntimeError): - _run(standalone_pm.emit('foo', 'bar', callback='cb')) + await standalone_pm.emit('foo', 'bar', callback='cb') - def test_emit_with_callback_missing_room(self): + async def test_emit_with_callback_missing_room(self): with mock.patch.object( self.pm, '_generate_ack_id', return_value='123' ): with pytest.raises(ValueError): - _run(self.pm.emit('foo', 'bar', callback='cb')) + await self.pm.emit('foo', 'bar', callback='cb') - def test_emit_with_ignore_queue(self): - sid = _run(self.pm.connect('123', '/')) - _run( - self.pm.emit( - 'foo', 'bar', room=sid, namespace='/', ignore_queue=True - ) + async def test_emit_with_ignore_queue(self): + sid = await self.pm.connect('123', '/') + await self.pm.emit( + 'foo', 'bar', room=sid, namespace='/', ignore_queue=True ) self.pm._publish.assert_not_awaited() assert self.pm.server._send_eio_packet.await_count == 1 @@ -171,33 +168,33 @@ class TestAsyncPubSubManager: pkt = self.pm.server._send_eio_packet.await_args_list[0][0][1] assert pkt.encode() == '42["foo","bar"]' - def test_can_disconnect(self): - sid = _run(self.pm.connect('123', '/')) - assert _run(self.pm.can_disconnect(sid, '/')) is True - _run(self.pm.can_disconnect(sid, '/foo')) + async def test_can_disconnect(self): + sid = await self.pm.connect('123', '/') + assert await self.pm.can_disconnect(sid, '/') is True + await self.pm.can_disconnect(sid, '/foo') self.pm._publish.assert_awaited_once_with( {'method': 'disconnect', 'sid': sid, 'namespace': '/foo', 'host_id': '123456'} ) - def test_disconnect(self): - _run(self.pm.disconnect('foo', '/')) + async def test_disconnect(self): + await self.pm.disconnect('foo', '/') self.pm._publish.assert_awaited_once_with( {'method': 'disconnect', 'sid': 'foo', 'namespace': '/', 'host_id': '123456'} ) - def test_disconnect_ignore_queue(self): - sid = _run(self.pm.connect('123', '/')) + async def test_disconnect_ignore_queue(self): + sid = await self.pm.connect('123', '/') self.pm.pre_disconnect(sid, '/') - _run(self.pm.disconnect(sid, '/', ignore_queue=True)) + await self.pm.disconnect(sid, '/', ignore_queue=True) self.pm._publish.assert_not_awaited() assert self.pm.is_connected(sid, '/') is False - def test_enter_room(self): - sid = _run(self.pm.connect('123', '/')) - _run(self.pm.enter_room(sid, '/', 'foo')) - _run(self.pm.enter_room('456', '/', 'foo')) + async def test_enter_room(self): + sid = await self.pm.connect('123', '/') + await self.pm.enter_room(sid, '/', 'foo') + await self.pm.enter_room('456', '/', 'foo') assert sid in self.pm.rooms['/']['foo'] assert self.pm.rooms['/']['foo'][sid] == '123' self.pm._publish.assert_awaited_once_with( @@ -205,35 +202,35 @@ class TestAsyncPubSubManager: 'namespace': '/', 'host_id': '123456'} ) - def test_leave_room(self): - sid = _run(self.pm.connect('123', '/')) - _run(self.pm.leave_room(sid, '/', 'foo')) - _run(self.pm.leave_room('456', '/', 'foo')) + async def test_leave_room(self): + sid = await self.pm.connect('123', '/') + await self.pm.leave_room(sid, '/', 'foo') + await self.pm.leave_room('456', '/', 'foo') assert 'foo' not in self.pm.rooms['/'] self.pm._publish.assert_awaited_once_with( {'method': 'leave_room', 'sid': '456', 'room': 'foo', 'namespace': '/', 'host_id': '123456'} ) - def test_close_room(self): - _run(self.pm.close_room('foo')) + async def test_close_room(self): + await self.pm.close_room('foo') self.pm._publish.assert_awaited_once_with( {'method': 'close_room', 'room': 'foo', 'namespace': '/', 'host_id': '123456'} ) - def test_close_room_with_namespace(self): - _run(self.pm.close_room('foo', '/bar')) + async def test_close_room_with_namespace(self): + await self.pm.close_room('foo', '/bar') self.pm._publish.assert_awaited_once_with( {'method': 'close_room', 'room': 'foo', 'namespace': '/bar', 'host_id': '123456'} ) - def test_handle_emit(self): + async def test_handle_emit(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run(self.pm._handle_emit({'event': 'foo', 'data': 'bar'})) + await self.pm._handle_emit({'event': 'foo', 'data': 'bar'}) super_emit.assert_awaited_once_with( 'foo', 'bar', @@ -243,14 +240,12 @@ class TestAsyncPubSubManager: callback=None, ) - def test_handle_emit_with_namespace(self): + async def test_handle_emit_with_namespace(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run( - self.pm._handle_emit( - {'event': 'foo', 'data': 'bar', 'namespace': '/baz'} - ) + await self.pm._handle_emit( + {'event': 'foo', 'data': 'bar', 'namespace': '/baz'} ) super_emit.assert_awaited_once_with( 'foo', @@ -261,14 +256,12 @@ class TestAsyncPubSubManager: callback=None, ) - def test_handle_emit_with_room(self): + async def test_handle_emit_with_room(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run( - self.pm._handle_emit( - {'event': 'foo', 'data': 'bar', 'room': 'baz'} - ) + await self.pm._handle_emit( + {'event': 'foo', 'data': 'bar', 'room': 'baz'} ) super_emit.assert_awaited_once_with( 'foo', @@ -279,14 +272,12 @@ class TestAsyncPubSubManager: callback=None, ) - def test_handle_emit_with_skip_sid(self): + async def test_handle_emit_with_skip_sid(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run( - self.pm._handle_emit( - {'event': 'foo', 'data': 'bar', 'skip_sid': '123'} - ) + await self.pm._handle_emit( + {'event': 'foo', 'data': 'bar', 'skip_sid': '123'} ) super_emit.assert_awaited_once_with( 'foo', @@ -297,20 +288,18 @@ class TestAsyncPubSubManager: callback=None, ) - def test_handle_emit_with_remote_callback(self): + async def test_handle_emit_with_remote_callback(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run( - self.pm._handle_emit( - { - 'event': 'foo', - 'data': 'bar', - 'namespace': '/baz', - 'callback': ('sid', '/baz', 123), - 'host_id': 'x', - } - ) + await self.pm._handle_emit( + { + 'event': 'foo', + 'data': 'bar', + 'namespace': '/baz', + 'callback': ('sid', '/baz', 123), + 'host_id': 'x', + } ) assert super_emit.await_count == 1 assert super_emit.await_args[0] == ('foo', 'bar') @@ -320,7 +309,7 @@ class TestAsyncPubSubManager: assert isinstance( super_emit.await_args[1]['callback'], functools.partial ) - _run(super_emit.await_args[1]['callback']('one', 2, 'three')) + await super_emit.await_args[1]['callback']('one', 2, 'three') self.pm._publish.assert_awaited_once_with( { 'method': 'callback', @@ -332,20 +321,18 @@ class TestAsyncPubSubManager: } ) - def test_handle_emit_with_local_callback(self): + async def test_handle_emit_with_local_callback(self): with mock.patch.object( async_manager.AsyncManager, 'emit' ) as super_emit: - _run( - self.pm._handle_emit( - { - 'event': 'foo', - 'data': 'bar', - 'namespace': '/baz', - 'callback': ('sid', '/baz', 123), - 'host_id': self.pm.host_id, - } - ) + await self.pm._handle_emit( + { + 'event': 'foo', + 'data': 'bar', + 'namespace': '/baz', + 'callback': ('sid', '/baz', 123), + 'host_id': self.pm.host_id, + } ) assert super_emit.await_count == 1 assert super_emit.await_args[0] == ('foo', 'bar') @@ -355,163 +342,137 @@ class TestAsyncPubSubManager: assert isinstance( super_emit.await_args[1]['callback'], functools.partial ) - _run(super_emit.await_args[1]['callback']('one', 2, 'three')) + await super_emit.await_args[1]['callback']('one', 2, 'three') self.pm._publish.assert_not_awaited() - def test_handle_callback(self): + async def test_handle_callback(self): host_id = self.pm.host_id with mock.patch.object( self.pm, 'trigger_callback' ) as trigger: - _run( - self.pm._handle_callback( - { - 'method': 'callback', - 'host_id': host_id, - 'sid': 'sid', - 'namespace': '/', - 'id': 123, - 'args': ('one', 2), - } - ) + await self.pm._handle_callback( + { + 'method': 'callback', + 'host_id': host_id, + 'sid': 'sid', + 'namespace': '/', + 'id': 123, + 'args': ('one', 2), + } ) trigger.assert_awaited_once_with('sid', 123, ('one', 2)) - def test_handle_callback_bad_host_id(self): + async def test_handle_callback_bad_host_id(self): with mock.patch.object( self.pm, 'trigger_callback' ) as trigger: - _run( - self.pm._handle_callback( - { - 'method': 'callback', - 'host_id': 'bad', - 'sid': 'sid', - 'namespace': '/', - 'id': 123, - 'args': ('one', 2), - } - ) + await self.pm._handle_callback( + { + 'method': 'callback', + 'host_id': 'bad', + 'sid': 'sid', + 'namespace': '/', + 'id': 123, + 'args': ('one', 2), + } ) assert trigger.await_count == 0 - def test_handle_callback_missing_args(self): + async def test_handle_callback_missing_args(self): host_id = self.pm.host_id with mock.patch.object( self.pm, 'trigger_callback' ) as trigger: - _run( - self.pm._handle_callback( - { - 'method': 'callback', - 'host_id': host_id, - 'sid': 'sid', - 'namespace': '/', - 'id': 123, - } - ) + await self.pm._handle_callback( + { + 'method': 'callback', + 'host_id': host_id, + 'sid': 'sid', + 'namespace': '/', + 'id': 123, + } ) - _run( - self.pm._handle_callback( - { - 'method': 'callback', - 'host_id': host_id, - 'sid': 'sid', - 'namespace': '/', - } - ) + await self.pm._handle_callback( + { + 'method': 'callback', + 'host_id': host_id, + 'sid': 'sid', + 'namespace': '/', + } ) - _run( - self.pm._handle_callback( - {'method': 'callback', 'host_id': host_id, 'sid': 'sid'} - ) + await self.pm._handle_callback( + {'method': 'callback', 'host_id': host_id, 'sid': 'sid'} ) - _run( - self.pm._handle_callback( - {'method': 'callback', 'host_id': host_id} - ) + await self.pm._handle_callback( + {'method': 'callback', 'host_id': host_id} ) assert trigger.await_count == 0 - def test_handle_disconnect(self): - _run( - self.pm._handle_disconnect( - {'method': 'disconnect', 'sid': '123', 'namespace': '/foo'} - ) + async def test_handle_disconnect(self): + await self.pm._handle_disconnect( + {'method': 'disconnect', 'sid': '123', 'namespace': '/foo'} ) self.pm.server.disconnect.assert_awaited_once_with( sid='123', namespace='/foo', ignore_queue=True ) - def test_handle_enter_room(self): - sid = _run(self.pm.connect('123', '/')) + async def test_handle_enter_room(self): + sid = await self.pm.connect('123', '/') with mock.patch.object( async_manager.AsyncManager, 'enter_room' ) as super_enter_room: - _run( - self.pm._handle_enter_room( - {'method': 'enter_room', 'sid': sid, 'namespace': '/', - 'room': 'foo'} - ) + await self.pm._handle_enter_room( + {'method': 'enter_room', 'sid': sid, 'namespace': '/', + 'room': 'foo'} ) - _run( - self.pm._handle_enter_room( - {'method': 'enter_room', 'sid': '456', 'namespace': '/', - 'room': 'foo'} - ) + await self.pm._handle_enter_room( + {'method': 'enter_room', 'sid': '456', 'namespace': '/', + 'room': 'foo'} ) super_enter_room.assert_awaited_once_with(sid, '/', 'foo') - def test_handle_leave_room(self): - sid = _run(self.pm.connect('123', '/')) + async def test_handle_leave_room(self): + sid = await self.pm.connect('123', '/') with mock.patch.object( async_manager.AsyncManager, 'leave_room' ) as super_leave_room: - _run( - self.pm._handle_leave_room( - {'method': 'leave_room', 'sid': sid, 'namespace': '/', - 'room': 'foo'} - ) + await self.pm._handle_leave_room( + {'method': 'leave_room', 'sid': sid, 'namespace': '/', + 'room': 'foo'} ) - _run( - self.pm._handle_leave_room( - {'method': 'leave_room', 'sid': '456', 'namespace': '/', - 'room': 'foo'} - ) + await self.pm._handle_leave_room( + {'method': 'leave_room', 'sid': '456', 'namespace': '/', + 'room': 'foo'} ) super_leave_room.assert_awaited_once_with(sid, '/', 'foo') - def test_handle_close_room(self): + async def test_handle_close_room(self): with mock.patch.object( async_manager.AsyncManager, 'close_room' ) as super_close_room: - _run( - self.pm._handle_close_room( - {'method': 'close_room', 'room': 'foo'} - ) + await self.pm._handle_close_room( + {'method': 'close_room', 'room': 'foo'} ) super_close_room.assert_awaited_once_with( room='foo', namespace=None ) - def test_handle_close_room_with_namespace(self): + async def test_handle_close_room_with_namespace(self): with mock.patch.object( async_manager.AsyncManager, 'close_room' ) as super_close_room: - _run( - self.pm._handle_close_room( - { - 'method': 'close_room', - 'room': 'foo', - 'namespace': '/bar', - } - ) + await self.pm._handle_close_room( + { + 'method': 'close_room', + 'room': 'foo', + 'namespace': '/bar', + } ) super_close_room.assert_awaited_once_with( room='foo', namespace='/bar' ) - def test_background_thread(self): + async def test_background_thread(self): self.pm._handle_emit = mock.AsyncMock() self.pm._handle_callback = mock.AsyncMock() self.pm._handle_disconnect = mock.AsyncMock() @@ -548,7 +509,7 @@ class TestAsyncPubSubManager: 'host_id': host_id}) self.pm._listen = messages - _run(self.pm._thread()) + await self.pm._thread() self.pm._handle_emit.assert_awaited_once_with( {'method': 'emit', 'value': 'foo', 'host_id': 'x'} @@ -575,7 +536,7 @@ class TestAsyncPubSubManager: {'method': 'close_room', 'value': 'baz', 'host_id': 'x'} ) - def test_background_thread_exception(self): + async def test_background_thread_exception(self): self.pm._handle_emit = mock.AsyncMock(side_effect=[ ValueError(), asyncio.CancelledError]) @@ -584,7 +545,7 @@ class TestAsyncPubSubManager: yield {'method': 'emit', 'value': 'bar', 'host_id': 'x'} self.pm._listen = messages - _run(self.pm._thread()) + await self.pm._thread() self.pm._handle_emit.assert_any_await( {'method': 'emit', 'value': 'foo', 'host_id': 'x'} diff --git a/tests/async/test_server.py b/tests/async/test_server.py index b2de48a..d9129d4 100644 --- a/tests/async/test_server.py +++ b/tests/async/test_server.py @@ -11,7 +11,6 @@ from socketio import async_namespace from socketio import exceptions from socketio import namespace from socketio import packet -from .helpers import _run @mock.patch('socketio.server.engineio.AsyncServer', **{ @@ -32,25 +31,25 @@ class TestAsyncServer: mgr.trigger_callback = mock.AsyncMock() return mgr - def test_create(self, eio): + async def test_create(self, eio): eio.return_value.handle_request = mock.AsyncMock() mgr = self._get_mock_manager() s = async_server.AsyncServer( client_manager=mgr, async_handlers=True, foo='bar' ) - _run(s.handle_request({})) - _run(s.handle_request({})) + await s.handle_request({}) + await s.handle_request({}) eio.assert_called_once_with(**{'foo': 'bar', 'async_handlers': False}) assert s.manager == mgr assert s.eio.on.call_count == 3 assert s.async_handlers - def test_attach(self, eio): + async def test_attach(self, eio): s = async_server.AsyncServer() s.attach('app', 'path') eio.return_value.attach.assert_called_once_with('app', 'path') - def test_on_event(self, eio): + async def test_on_event(self, eio): s = async_server.AsyncServer() @s.on('connect') @@ -67,18 +66,16 @@ class TestAsyncServer: assert s.handlers['/']['disconnect'] == bar assert s.handlers['/foo']['disconnect'] == bar - def test_emit(self, eio): + async def test_emit(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run( - s.emit( - 'my event', - {'foo': 'bar'}, - to='room', - skip_sid='123', - namespace='/foo', - callback='cb', - ) + await s.emit( + 'my event', + {'foo': 'bar'}, + to='room', + skip_sid='123', + namespace='/foo', + callback='cb', ) s.manager.emit.assert_awaited_once_with( 'my event', @@ -89,16 +86,14 @@ class TestAsyncServer: callback='cb', ignore_queue=False, ) - _run( - s.emit( - 'my event', - {'foo': 'bar'}, - room='room', - skip_sid='123', - namespace='/foo', - callback='cb', - ignore_queue=True, - ) + await s.emit( + 'my event', + {'foo': 'bar'}, + room='room', + skip_sid='123', + namespace='/foo', + callback='cb', + ignore_queue=True, ) s.manager.emit.assert_awaited_with( 'my event', @@ -110,17 +105,15 @@ class TestAsyncServer: ignore_queue=True, ) - def test_emit_default_namespace(self, eio): + async def test_emit_default_namespace(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run( - s.emit( - 'my event', - {'foo': 'bar'}, - to='room', - skip_sid='123', - callback='cb', - ) + await s.emit( + 'my event', + {'foo': 'bar'}, + to='room', + skip_sid='123', + callback='cb', ) s.manager.emit.assert_awaited_once_with( 'my event', @@ -131,15 +124,13 @@ class TestAsyncServer: callback='cb', ignore_queue=False, ) - _run( - s.emit( - 'my event', - {'foo': 'bar'}, - room='room', - skip_sid='123', - callback='cb', - ignore_queue=True, - ) + await s.emit( + 'my event', + {'foo': 'bar'}, + room='room', + skip_sid='123', + callback='cb', + ignore_queue=True, ) s.manager.emit.assert_awaited_with( 'my event', @@ -151,17 +142,15 @@ class TestAsyncServer: ignore_queue=True, ) - def test_send(self, eio): + async def test_send(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run( - s.send( - 'foo', - to='room', - skip_sid='123', - namespace='/foo', - callback='cb', - ) + await s.send( + 'foo', + to='room', + skip_sid='123', + namespace='/foo', + callback='cb', ) s.manager.emit.assert_awaited_once_with( 'message', @@ -172,15 +161,13 @@ class TestAsyncServer: callback='cb', ignore_queue=False, ) - _run( - s.send( - 'foo', - room='room', - skip_sid='123', - namespace='/foo', - callback='cb', - ignore_queue=True, - ) + await s.send( + 'foo', + room='room', + skip_sid='123', + namespace='/foo', + callback='cb', + ignore_queue=True, ) s.manager.emit.assert_awaited_with( 'message', @@ -192,7 +179,7 @@ class TestAsyncServer: ignore_queue=True, ) - def test_call(self, eio): + async def test_call(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) @@ -201,9 +188,9 @@ class TestAsyncServer: return True s.eio.create_event.return_value.wait = fake_event_wait - assert _run(s.call('foo', sid='123')) == ('foo', 321) + assert await s.call('foo', sid='123') == ('foo', 321) - def test_call_with_timeout(self, eio): + async def test_call_with_timeout(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) @@ -212,253 +199,253 @@ class TestAsyncServer: s.eio.create_event.return_value.wait = fake_event_wait with pytest.raises(exceptions.TimeoutError): - _run(s.call('foo', sid='123', timeout=0.01)) + await s.call('foo', sid='123', timeout=0.01) - def test_call_with_broadcast(self, eio): + async def test_call_with_broadcast(self, eio): s = async_server.AsyncServer() with pytest.raises(ValueError): - _run(s.call('foo')) + await s.call('foo') - def test_call_without_async_handlers(self, eio): + async def test_call_without_async_handlers(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer( client_manager=mgr, async_handlers=False ) with pytest.raises(RuntimeError): - _run(s.call('foo', sid='123', timeout=12)) + await s.call('foo', sid='123', timeout=12) - def test_enter_room(self, eio): + async def test_enter_room(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.enter_room('123', 'room', namespace='/foo')) + await s.enter_room('123', 'room', namespace='/foo') s.manager.enter_room.assert_awaited_once_with('123', '/foo', 'room') - def test_enter_room_default_namespace(self, eio): + async def test_enter_room_default_namespace(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.enter_room('123', 'room')) + await s.enter_room('123', 'room') s.manager.enter_room.assert_awaited_once_with('123', '/', 'room') - def test_leave_room(self, eio): + async def test_leave_room(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.leave_room('123', 'room', namespace='/foo')) + await s.leave_room('123', 'room', namespace='/foo') s.manager.leave_room.assert_awaited_once_with('123', '/foo', 'room') - def test_leave_room_default_namespace(self, eio): + async def test_leave_room_default_namespace(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.leave_room('123', 'room')) + await s.leave_room('123', 'room') s.manager.leave_room.assert_awaited_once_with('123', '/', 'room') - def test_close_room(self, eio): + async def test_close_room(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.close_room('room', namespace='/foo')) + await s.close_room('room', namespace='/foo') s.manager.close_room.assert_awaited_once_with('room', '/foo') - def test_close_room_default_namespace(self, eio): + async def test_close_room_default_namespace(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s.close_room('room')) + await s.close_room('room') s.manager.close_room.assert_awaited_once_with('room', '/') - def test_rooms(self, eio): + async def test_rooms(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) s.rooms('123', namespace='/foo') s.manager.get_rooms.assert_called_once_with('123', '/foo') - def test_rooms_default_namespace(self, eio): + async def test_rooms_default_namespace(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) s.rooms('123') s.manager.get_rooms.assert_called_once_with('123', '/') - def test_handle_request(self, eio): + async def test_handle_request(self, eio): eio.return_value.handle_request = mock.AsyncMock() s = async_server.AsyncServer() - _run(s.handle_request('environ')) + await s.handle_request('environ') s.eio.handle_request.assert_awaited_once_with('environ') - def test_send_packet(self, eio): + async def test_send_packet(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() - _run(s._send_packet('123', packet.Packet( - packet.EVENT, ['my event', 'my data'], namespace='/foo'))) + await s._send_packet('123', packet.Packet( + packet.EVENT, ['my event', 'my data'], namespace='/foo')) s.eio.send.assert_awaited_once_with( '123', '2/foo,["my event","my data"]' ) - def test_send_eio_packet(self, eio): + async def test_send_eio_packet(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() - _run(s._send_eio_packet('123', eio_packet.Packet( - eio_packet.MESSAGE, 'hello'))) + await s._send_eio_packet('123', eio_packet.Packet( + eio_packet.MESSAGE, 'hello')) assert s.eio.send_packet.await_count == 1 assert s.eio.send_packet.await_args_list[0][0][0] == '123' pkt = s.eio.send_packet.await_args_list[0][0][1] assert pkt.encode() == '4hello' - def test_transport(self, eio): + async def test_transport(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.eio.transport = mock.MagicMock(return_value='polling') - sid_foo = _run(s.manager.connect('123', '/foo')) + sid_foo = await s.manager.connect('123', '/foo') assert s.transport(sid_foo, '/foo') == 'polling' s.eio.transport.assert_called_once_with('123') - def test_handle_connect(self, eio): + async def test_handle_connect(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.manager.initialize = mock.MagicMock() handler = mock.MagicMock() s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with('123', '0{"sid":"1"}') assert s.manager.initialize.call_count == 1 - _run(s._handle_eio_connect('456', 'environ')) - _run(s._handle_eio_message('456', '0')) + await s._handle_eio_connect('456', 'environ') + await s._handle_eio_message('456', '0') assert s.manager.initialize.call_count == 1 - def test_handle_connect_with_auth(self, eio): + async def test_handle_connect_with_auth(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.manager.initialize = mock.MagicMock() handler = mock.MagicMock() s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0{"token":"abc"}')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0{"token":"abc"}') assert s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ', {'token': 'abc'}) s.eio.send.assert_awaited_once_with('123', '0{"sid":"1"}') assert s.manager.initialize.call_count == 1 - _run(s._handle_eio_connect('456', 'environ')) - _run(s._handle_eio_message('456', '0')) + await s._handle_eio_connect('456', 'environ') + await s._handle_eio_message('456', '0') assert s.manager.initialize.call_count == 1 - def test_handle_connect_with_auth_none(self, eio): + async def test_handle_connect_with_auth_none(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.manager.initialize = mock.MagicMock() handler = mock.MagicMock(side_effect=[TypeError, None, None]) s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert s.manager.is_connected('1', '/') handler.assert_called_with('1', 'environ', None) s.eio.send.assert_awaited_once_with('123', '0{"sid":"1"}') assert s.manager.initialize.call_count == 1 - _run(s._handle_eio_connect('456', 'environ')) - _run(s._handle_eio_message('456', '0')) + await s._handle_eio_connect('456', 'environ') + await s._handle_eio_message('456', '0') assert s.manager.initialize.call_count == 1 - def test_handle_connect_async(self, eio): + async def test_handle_connect_async(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.manager.initialize = mock.MagicMock() handler = mock.AsyncMock() s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert s.manager.is_connected('1', '/') handler.assert_awaited_once_with('1', 'environ') s.eio.send.assert_awaited_once_with('123', '0{"sid":"1"}') assert s.manager.initialize.call_count == 1 - _run(s._handle_eio_connect('456', 'environ')) - _run(s._handle_eio_message('456', '0')) + await s._handle_eio_connect('456', 'environ') + await s._handle_eio_message('456', '0') assert s.manager.initialize.call_count == 1 - def test_handle_connect_with_default_implied_namespaces(self, eio): + async def test_handle_connect_with_default_implied_namespaces(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s._handle_eio_message('123', '0/foo,') assert s.manager.is_connected('1', '/') assert not s.manager.is_connected('2', '/foo') - def test_handle_connect_with_implied_namespaces(self, eio): + async def test_handle_connect_with_implied_namespaces(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(namespaces=['/foo']) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s._handle_eio_message('123', '0/foo,') assert not s.manager.is_connected('1', '/') assert s.manager.is_connected('1', '/foo') - def test_handle_connect_with_all_implied_namespaces(self, eio): + async def test_handle_connect_with_all_implied_namespaces(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(namespaces='*') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s._handle_eio_message('123', '0/foo,') assert s.manager.is_connected('1', '/') assert s.manager.is_connected('2', '/foo') - def test_handle_connect_namespace(self, eio): + async def test_handle_connect_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock() s.on('connect', handler, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with('123', '0/foo,{"sid":"1"}') - def test_handle_connect_always_connect(self, eio): + async def test_handle_connect_always_connect(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(always_connect=True) s.manager.initialize = mock.MagicMock() handler = mock.MagicMock() s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with('123', '0{"sid":"1"}') assert s.manager.initialize.call_count == 1 - _run(s._handle_eio_connect('456', 'environ')) - _run(s._handle_eio_message('456', '0')) + await s._handle_eio_connect('456', 'environ') + await s._handle_eio_message('456', '0') assert s.manager.initialize.call_count == 1 - def test_handle_connect_rejected(self, eio): + async def test_handle_connect_rejected(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock(return_value=False) s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert not s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with( '123', '4{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_namespace_rejected(self, eio): + async def test_handle_connect_namespace_rejected(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock(return_value=False) s.on('connect', handler, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert not s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_any_await( '123', '4/foo,{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_rejected_always_connect(self, eio): + async def test_handle_connect_rejected_always_connect(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(always_connect=True) handler = mock.MagicMock(return_value=False) s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert not s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_any_await('123', '0{"sid":"1"}') @@ -466,13 +453,13 @@ class TestAsyncServer: '123', '1{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_namespace_rejected_always_connect(self, eio): + async def test_handle_connect_namespace_rejected_always_connect(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(always_connect=True) handler = mock.MagicMock(return_value=False) s.on('connect', handler, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert not s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_any_await('123', '0/foo,{"sid":"1"}') @@ -480,37 +467,37 @@ class TestAsyncServer: '123', '1/foo,{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_rejected_with_exception(self, eio): + async def test_handle_connect_rejected_with_exception(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock( side_effect=exceptions.ConnectionRefusedError('fail_reason') ) s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert not s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with( '123', '4{"message":"fail_reason"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_rejected_with_empty_exception(self, eio): + async def test_handle_connect_rejected_with_empty_exception(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock( side_effect=exceptions.ConnectionRefusedError() ) s.on('connect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') assert not s.manager.is_connected('1', '/') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with( '123', '4{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_connect_namespace_rejected_with_exception(self, eio): + async def test_handle_connect_namespace_rejected_with_exception(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock( @@ -518,109 +505,110 @@ class TestAsyncServer: 'fail_reason', 1, '2') ) s.on('connect', handler, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert not s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with( '123', '4/foo,{"message":"fail_reason","data":[1,"2"]}') assert s.environ == {'123': 'environ'} - def test_handle_connect_namespace_rejected_with_empty_exception(self, eio): + async def test_handle_connect_namespace_rejected_with_empty_exception( + self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock( side_effect=exceptions.ConnectionRefusedError() ) s.on('connect', handler, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert not s.manager.is_connected('1', '/foo') handler.assert_called_once_with('1', 'environ') s.eio.send.assert_awaited_once_with( '123', '4/foo,{"message":"Connection rejected by server"}') assert s.environ == {'123': 'environ'} - def test_handle_disconnect(self, eio): + async def test_handle_disconnect(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.manager.disconnect = mock.AsyncMock() handler = mock.MagicMock() s.on('disconnect', handler) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s._handle_eio_disconnect('123')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s._handle_eio_disconnect('123') handler.assert_called_once_with('1') s.manager.disconnect.assert_awaited_once_with( '1', '/', ignore_queue=True) assert s.environ == {} - def test_handle_disconnect_namespace(self, eio): + async def test_handle_disconnect_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock() s.on('disconnect', handler) handler_namespace = mock.MagicMock() s.on('disconnect', handler_namespace, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) - _run(s._handle_eio_disconnect('123')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') + await s._handle_eio_disconnect('123') handler.assert_not_called() handler_namespace.assert_called_once_with('1') assert s.environ == {} - def test_handle_disconnect_only_namespace(self, eio): + async def test_handle_disconnect_only_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() handler = mock.MagicMock() s.on('disconnect', handler) handler_namespace = mock.MagicMock() s.on('disconnect', handler_namespace, namespace='/foo') - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) - _run(s._handle_eio_message('123', '1/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') + await s._handle_eio_message('123', '1/foo,') assert handler.call_count == 0 handler_namespace.assert_called_once_with('1') assert s.environ == {'123': 'environ'} - def test_handle_disconnect_unknown_client(self, eio): + async def test_handle_disconnect_unknown_client(self, eio): mgr = self._get_mock_manager() s = async_server.AsyncServer(client_manager=mgr) - _run(s._handle_eio_disconnect('123')) + await s._handle_eio_disconnect('123') - def test_handle_event(self, eio): + async def test_handle_event(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.AsyncMock() catchall_handler = mock.AsyncMock() s.on('msg', handler) s.on('*', catchall_handler) - _run(s._handle_eio_message('123', '2["msg","a","b"]')) - _run(s._handle_eio_message('123', '2["my message","a","b","c"]')) + await s._handle_eio_message('123', '2["msg","a","b"]') + await s._handle_eio_message('123', '2["my message","a","b","c"]') handler.assert_awaited_once_with(sid, 'a', 'b') catchall_handler.assert_awaited_once_with( 'my message', sid, 'a', 'b', 'c') - def test_handle_event_with_namespace(self, eio): + async def test_handle_event_with_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/foo')) + sid = await s.manager.connect('123', '/foo') handler = mock.MagicMock() catchall_handler = mock.MagicMock() s.on('msg', handler, namespace='/foo') s.on('*', catchall_handler, namespace='/foo') - _run(s._handle_eio_message('123', '2/foo,["msg","a","b"]')) - _run(s._handle_eio_message('123', '2/foo,["my message","a","b","c"]')) + await s._handle_eio_message('123', '2/foo,["msg","a","b"]') + await s._handle_eio_message('123', '2/foo,["my message","a","b","c"]') handler.assert_called_once_with(sid, 'a', 'b') catchall_handler.assert_called_once_with( 'my message', sid, 'a', 'b', 'c') - def test_handle_event_with_catchall_namespace(self, eio): + async def test_handle_event_with_catchall_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid_foo = _run(s.manager.connect('123', '/foo')) - sid_bar = _run(s.manager.connect('123', '/bar')) + sid_foo = await s.manager.connect('123', '/foo') + sid_bar = await s.manager.connect('123', '/bar') connect_star_handler = mock.MagicMock() msg_foo_handler = mock.MagicMock() msg_star_handler = mock.MagicMock() @@ -631,12 +619,12 @@ class TestAsyncServer: s.on('msg', msg_star_handler, namespace='*') s.on('*', star_foo_handler, namespace='/foo') s.on('*', star_star_handler, namespace='*') - _run(s._trigger_event('connect', '/bar', sid_bar)) - _run(s._handle_eio_message('123', '2/foo,["msg","a","b"]')) - _run(s._handle_eio_message('123', '2/bar,["msg","a","b"]')) - _run(s._handle_eio_message('123', '2/foo,["my message","a","b","c"]')) - _run(s._handle_eio_message('123', '2/bar,["my message","a","b","c"]')) - _run(s._trigger_event('disconnect', '/bar', sid_bar)) + await s._trigger_event('connect', '/bar', sid_bar) + await s._handle_eio_message('123', '2/foo,["msg","a","b"]') + await s._handle_eio_message('123', '2/bar,["msg","a","b"]') + await s._handle_eio_message('123', '2/foo,["my message","a","b","c"]') + await s._handle_eio_message('123', '2/bar,["my message","a","b","c"]') + await s._trigger_event('disconnect', '/bar', sid_bar) connect_star_handler.assert_called_once_with('/bar', sid_bar) msg_foo_handler.assert_called_once_with(sid_foo, 'a', 'b') msg_star_handler.assert_called_once_with('/bar', sid_bar, 'a', 'b') @@ -645,157 +633,151 @@ class TestAsyncServer: star_star_handler.assert_called_once_with( 'my message', '/bar', sid_bar, 'a', 'b', 'c') - def test_handle_event_with_disconnected_namespace(self, eio): + async def test_handle_event_with_disconnected_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - _run(s.manager.connect('123', '/foo')) + await s.manager.connect('123', '/foo') handler = mock.MagicMock() s.on('my message', handler, namespace='/bar') - _run(s._handle_eio_message('123', '2/bar,["my message","a","b","c"]')) + await s._handle_eio_message('123', '2/bar,["my message","a","b","c"]') handler.assert_not_called() - def test_handle_event_binary(self, eio): + async def test_handle_event_binary(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock() s.on('my message', handler) - _run( - s._handle_eio_message( - '123', - '52-["my message","a",' - '{"_placeholder":true,"num":1},' - '{"_placeholder":true,"num":0}]', - ) + await s._handle_eio_message( + '123', + '52-["my message","a",' + '{"_placeholder":true,"num":1},' + '{"_placeholder":true,"num":0}]', ) - _run(s._handle_eio_message('123', b'foo')) - _run(s._handle_eio_message('123', b'bar')) + await s._handle_eio_message('123', b'foo') + await s._handle_eio_message('123', b'bar') handler.assert_called_once_with(sid, 'a', b'bar', b'foo') - def test_handle_event_binary_ack(self, eio): + async def test_handle_event_binary_ack(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) s.manager.trigger_callback = mock.AsyncMock() - sid = _run(s.manager.connect('123', '/')) - _run( - s._handle_eio_message( - '123', - '61-321["my message","a",' '{"_placeholder":true,"num":0}]', - ) + sid = await s.manager.connect('123', '/') + await s._handle_eio_message( + '123', + '61-321["my message","a",' '{"_placeholder":true,"num":0}]', ) - _run(s._handle_eio_message('123', b'foo')) + await s._handle_eio_message('123', b'foo') s.manager.trigger_callback.assert_awaited_once_with( sid, 321, ['my message', 'a', b'foo'] ) - def test_handle_event_with_ack(self, eio): + async def test_handle_event_with_ack(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock(return_value='foo') s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["my message","foo"]')) + await s._handle_eio_message('123', '21000["my message","foo"]') handler.assert_called_once_with(sid, 'foo') s.eio.send.assert_awaited_once_with( '123', '31000["foo"]' ) - def test_handle_unknown_event_with_ack(self, eio): + async def test_handle_unknown_event_with_ack(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - _run(s.manager.connect('123', '/')) + await s.manager.connect('123', '/') handler = mock.MagicMock(return_value='foo') s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["another message","foo"]')) + await s._handle_eio_message('123', '21000["another message","foo"]') s.eio.send.assert_not_awaited() - def test_handle_event_with_ack_none(self, eio): + async def test_handle_event_with_ack_none(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock(return_value=None) s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["my message","foo"]')) + await s._handle_eio_message('123', '21000["my message","foo"]') handler.assert_called_once_with(sid, 'foo') s.eio.send.assert_awaited_once_with('123', '31000[]') - def test_handle_event_with_ack_tuple(self, eio): + async def test_handle_event_with_ack_tuple(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock(return_value=(1, '2', True)) s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["my message","a","b","c"]')) + await s._handle_eio_message('123', '21000["my message","a","b","c"]') handler.assert_called_once_with(sid, 'a', 'b', 'c') s.eio.send.assert_awaited_once_with( '123', '31000[1,"2",true]' ) - def test_handle_event_with_ack_list(self, eio): + async def test_handle_event_with_ack_list(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock(return_value=[1, '2', True]) s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["my message","a","b","c"]')) + await s._handle_eio_message('123', '21000["my message","a","b","c"]') handler.assert_called_once_with(sid, 'a', 'b', 'c') s.eio.send.assert_awaited_once_with( '123', '31000[[1,"2",true]]' ) - def test_handle_event_with_ack_binary(self, eio): + async def test_handle_event_with_ack_binary(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer(async_handlers=False) - sid = _run(s.manager.connect('123', '/')) + sid = await s.manager.connect('123', '/') handler = mock.MagicMock(return_value=b'foo') s.on('my message', handler) - _run(s._handle_eio_message('123', '21000["my message","foo"]')) + await s._handle_eio_message('123', '21000["my message","foo"]') handler.assert_any_call(sid, 'foo') - def test_handle_error_packet(self, eio): + async def test_handle_error_packet(self, eio): s = async_server.AsyncServer() with pytest.raises(ValueError): - _run(s._handle_eio_message('123', '4')) + await s._handle_eio_message('123', '4') - def test_handle_invalid_packet(self, eio): + async def test_handle_invalid_packet(self, eio): s = async_server.AsyncServer() with pytest.raises(ValueError): - _run(s._handle_eio_message('123', '9')) + await s._handle_eio_message('123', '9') - def test_send_with_ack(self, eio): + async def test_send_with_ack(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.handlers['/'] = {} - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') cb = mock.MagicMock() id1 = s.manager._generate_ack_id('1', cb) id2 = s.manager._generate_ack_id('1', cb) - _run(s._send_packet('123', packet.Packet( - packet.EVENT, ['my event', 'foo'], id=id1))) - _run(s._send_packet('123', packet.Packet( - packet.EVENT, ['my event', 'bar'], id=id2))) - _run(s._handle_eio_message('123', '31["foo",2]')) + await s._send_packet('123', packet.Packet( + packet.EVENT, ['my event', 'foo'], id=id1)) + await s._send_packet('123', packet.Packet( + packet.EVENT, ['my event', 'bar'], id=id2)) + await s._handle_eio_message('123', '31["foo",2]') cb.assert_called_once_with('foo', 2) - def test_send_with_ack_namespace(self, eio): + async def test_send_with_ack_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() s.handlers['/foo'] = {} - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') cb = mock.MagicMock() id = s.manager._generate_ack_id('1', cb) - _run( - s._send_packet( - '123', packet.Packet(packet.EVENT, ['my event', 'foo'], - namespace='/foo', id=id) - ) + await s._send_packet( + '123', packet.Packet(packet.EVENT, ['my event', 'foo'], + namespace='/foo', id=id) ) - _run(s._handle_eio_message('123', '3/foo,1["foo",2]')) + await s._handle_eio_message('123', '3/foo,1["foo",2]') cb.assert_called_once_with('foo', 2) - def test_session(self, eio): + async def test_session(self, eio): fake_session = {} async def fake_get_session(eio_sid): @@ -836,65 +818,65 @@ class TestAsyncServer: '/ns': {'a': 'b'}, } - _run(_test()) + await _test() - def test_disconnect(self, eio): + async def test_disconnect(self, eio): eio.return_value.send = mock.AsyncMock() eio.return_value.disconnect = mock.AsyncMock() s = async_server.AsyncServer() s.handlers['/'] = {} - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s.disconnect('1')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s.disconnect('1') s.eio.send.assert_any_await('123', '1') assert not s.manager.is_connected('1', '/') - def test_disconnect_ignore_queue(self, eio): + async def test_disconnect_ignore_queue(self, eio): eio.return_value.send = mock.AsyncMock() eio.return_value.disconnect = mock.AsyncMock() s = async_server.AsyncServer() s.handlers['/'] = {} - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s.disconnect('1', ignore_queue=True)) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s.disconnect('1', ignore_queue=True) s.eio.send.assert_any_await('123', '1') assert not s.manager.is_connected('1', '/') - def test_disconnect_namespace(self, eio): + async def test_disconnect_namespace(self, eio): eio.return_value.send = mock.AsyncMock() eio.return_value.disconnect = mock.AsyncMock() s = async_server.AsyncServer() s.handlers['/foo'] = {} - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) - _run(s.disconnect('1', namespace='/foo')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') + await s.disconnect('1', namespace='/foo') s.eio.send.assert_any_await('123', '1/foo,') assert not s.manager.is_connected('1', '/foo') - def test_disconnect_twice(self, eio): + async def test_disconnect_twice(self, eio): eio.return_value.send = mock.AsyncMock() eio.return_value.disconnect = mock.AsyncMock() s = async_server.AsyncServer() - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0')) - _run(s.disconnect('1')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0') + await s.disconnect('1') calls = s.eio.send.await_count assert not s.manager.is_connected('1', '/') - _run(s.disconnect('1')) + await s.disconnect('1') assert calls == s.eio.send.await_count - def test_disconnect_twice_namespace(self, eio): + async def test_disconnect_twice_namespace(self, eio): eio.return_value.send = mock.AsyncMock() s = async_server.AsyncServer() - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) - _run(s.disconnect('1', namespace='/foo')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') + await s.disconnect('1', namespace='/foo') calls = s.eio.send.await_count assert not s.manager.is_connected('1', '/foo') - _run(s.disconnect('1', namespace='/foo')) + await s.disconnect('1', namespace='/foo') assert calls == s.eio.send.await_count - def test_namespace_handler(self, eio): + async def test_namespace_handler(self, eio): eio.return_value.send = mock.AsyncMock() result = {} @@ -916,19 +898,19 @@ class TestAsyncServer: s = async_server.AsyncServer(async_handlers=False) s.register_namespace(MyNamespace('/foo')) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert result['result'] == ('1', 'environ') - _run(s._handle_eio_message('123', '2/foo,["foo","a"]')) + await s._handle_eio_message('123', '2/foo,["foo","a"]') assert result['result'] == ('1', 'a') - _run(s._handle_eio_message('123', '2/foo,["bar"]')) + await s._handle_eio_message('123', '2/foo,["bar"]') assert result['result'] == 'bar' - _run(s._handle_eio_message('123', '2/foo,["baz","a","b"]')) + await s._handle_eio_message('123', '2/foo,["baz","a","b"]') assert result['result'] == ('a', 'b') - _run(s.disconnect('1', '/foo')) + await s.disconnect('1', '/foo') assert result['result'] == ('disconnect', '1') - def test_catchall_namespace_handler(self, eio): + async def test_catchall_namespace_handler(self, eio): eio.return_value.send = mock.AsyncMock() result = {} @@ -950,19 +932,19 @@ class TestAsyncServer: s = async_server.AsyncServer(async_handlers=False, namespaces='*') s.register_namespace(MyNamespace('*')) - _run(s._handle_eio_connect('123', 'environ')) - _run(s._handle_eio_message('123', '0/foo,')) + await s._handle_eio_connect('123', 'environ') + await s._handle_eio_message('123', '0/foo,') assert result['result'] == ('1', '/foo', 'environ') - _run(s._handle_eio_message('123', '2/foo,["foo","a"]')) + await s._handle_eio_message('123', '2/foo,["foo","a"]') assert result['result'] == ('1', '/foo', 'a') - _run(s._handle_eio_message('123', '2/foo,["bar"]')) + await s._handle_eio_message('123', '2/foo,["bar"]') assert result['result'] == 'bar/foo' - _run(s._handle_eio_message('123', '2/foo,["baz","a","b"]')) + await s._handle_eio_message('123', '2/foo,["baz","a","b"]') assert result['result'] == ('/foo', 'a', 'b') - _run(s.disconnect('1', '/foo')) + await s.disconnect('1', '/foo') assert result['result'] == ('disconnect', '1', '/foo') - def test_bad_namespace_handler(self, eio): + async def test_bad_namespace_handler(self, eio): class Dummy: pass @@ -981,7 +963,7 @@ class TestAsyncServer: with pytest.raises(ValueError): s.register_namespace(SyncNS()) - def test_logger(self, eio): + async def test_logger(self, eio): s = async_server.AsyncServer(logger=False) assert s.logger.getEffectiveLevel() == logging.ERROR s.logger.setLevel(logging.NOTSET) @@ -994,13 +976,13 @@ class TestAsyncServer: s = async_server.AsyncServer(logger='foo') assert s.logger == 'foo' - def test_engineio_logger(self, eio): + async def test_engineio_logger(self, eio): async_server.AsyncServer(engineio_logger='foo') eio.assert_called_once_with( **{'logger': 'foo', 'async_handlers': False} ) - def test_custom_json(self, eio): + async def test_custom_json(self, eio): # Warning: this test cannot run in parallel with other tests, as it # changes the JSON encoding/decoding functions @@ -1029,10 +1011,10 @@ class TestAsyncServer: # restore the default JSON module packet.Packet.json = json - def test_async_handlers(self, eio): + async def test_async_handlers(self, eio): s = async_server.AsyncServer(async_handlers=True) - _run(s.manager.connect('123', '/')) - _run(s._handle_eio_message('123', '2["my message","a","b","c"]')) + await s.manager.connect('123', '/') + await s._handle_eio_message('123', '2["my message","a","b","c"]') s.eio.start_background_task.assert_called_once_with( s._handle_event_internal, s, @@ -1043,21 +1025,21 @@ class TestAsyncServer: None, ) - def test_shutdown(self, eio): + async def test_shutdown(self, eio): s = async_server.AsyncServer() s.eio.shutdown = mock.AsyncMock() - _run(s.shutdown()) + await s.shutdown() s.eio.shutdown.assert_awaited_once_with() - def test_start_background_task(self, eio): + async def test_start_background_task(self, eio): s = async_server.AsyncServer() s.start_background_task('foo', 'bar', baz='baz') s.eio.start_background_task.assert_called_once_with( 'foo', 'bar', baz='baz' ) - def test_sleep(self, eio): + async def test_sleep(self, eio): eio.return_value.sleep = mock.AsyncMock() s = async_server.AsyncServer() - _run(s.sleep(1.23)) + await s.sleep(1.23) s.eio.sleep.assert_awaited_once_with(1.23) diff --git a/tests/async/test_simple_client.py b/tests/async/test_simple_client.py index a8d08f4..0892692 100644 --- a/tests/async/test_simple_client.py +++ b/tests/async/test_simple_client.py @@ -4,11 +4,10 @@ import pytest from socketio import AsyncSimpleClient from socketio.exceptions import SocketIOError, TimeoutError, DisconnectedError -from .helpers import _run class TestAsyncAsyncSimpleClient: - def test_constructor(self): + async def test_constructor(self): client = AsyncSimpleClient(1, '2', a='3', b=4) assert client.client_args == (1, '2') assert client.client_kwargs == {'a': '3', 'b': 4} @@ -16,15 +15,15 @@ class TestAsyncAsyncSimpleClient: assert client.input_buffer == [] assert not client.connected - def test_connect(self): + async def test_connect(self): client = AsyncSimpleClient(123, a='b') with mock.patch('socketio.async_simple_client.AsyncClient') \ as mock_client: mock_client.return_value.connect = mock.AsyncMock() - _run(client.connect('url', headers='h', auth='a', transports='t', - namespace='n', socketio_path='s', - wait_timeout='w')) + await client.connect('url', headers='h', auth='a', transports='t', + namespace='n', socketio_path='s', + wait_timeout='w') mock_client.assert_called_once_with(123, a='b') assert client.client == mock_client() mock_client().connect.assert_awaited_once_with( @@ -35,7 +34,7 @@ class TestAsyncAsyncSimpleClient: assert client.namespace == 'n' assert not client.input_event.is_set() - def test_connect_context_manager(self): + async def test_connect_context_manager(self): async def _t(): async with AsyncSimpleClient(123, a='b') as client: with mock.patch('socketio.async_simple_client.AsyncClient') \ @@ -56,17 +55,17 @@ class TestAsyncAsyncSimpleClient: assert client.namespace == 'n' assert not client.input_event.is_set() - _run(_t()) + await _t() - def test_connect_twice(self): + async def test_connect_twice(self): client = AsyncSimpleClient(123, a='b') client.client = mock.MagicMock() client.connected = True with pytest.raises(RuntimeError): - _run(client.connect('url')) + await client.connect('url') - def test_properties(self): + async def test_properties(self): client = AsyncSimpleClient() client.client = mock.MagicMock(transport='websocket') client.client.get_sid.return_value = 'sid' @@ -76,7 +75,7 @@ class TestAsyncAsyncSimpleClient: assert client.sid == 'sid' assert client.transport == 'websocket' - def test_emit(self): + async def test_emit(self): client = AsyncSimpleClient() client.client = mock.MagicMock() client.client.emit = mock.AsyncMock() @@ -84,18 +83,18 @@ class TestAsyncAsyncSimpleClient: client.connected_event.set() client.connected = True - _run(client.emit('foo', 'bar')) + await client.emit('foo', 'bar') client.client.emit.assert_awaited_once_with('foo', 'bar', namespace='/ns') - def test_emit_disconnected(self): + async def test_emit_disconnected(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = False with pytest.raises(DisconnectedError): - _run(client.emit('foo', 'bar')) + await client.emit('foo', 'bar') - def test_emit_retries(self): + async def test_emit_retries(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = True @@ -103,10 +102,10 @@ class TestAsyncAsyncSimpleClient: client.client.emit = mock.AsyncMock() client.client.emit.side_effect = [SocketIOError(), None] - _run(client.emit('foo', 'bar')) + await client.emit('foo', 'bar') client.client.emit.assert_awaited_with('foo', 'bar', namespace='/') - def test_call(self): + async def test_call(self): client = AsyncSimpleClient() client.client = mock.MagicMock() client.client.call = mock.AsyncMock() @@ -115,18 +114,18 @@ class TestAsyncAsyncSimpleClient: client.connected_event.set() client.connected = True - assert _run(client.call('foo', 'bar')) == 'result' + assert await client.call('foo', 'bar') == 'result' client.client.call.assert_awaited_once_with( 'foo', 'bar', namespace='/ns', timeout=60) - def test_call_disconnected(self): + async def test_call_disconnected(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = False with pytest.raises(DisconnectedError): - _run(client.call('foo', 'bar')) + await client.call('foo', 'bar') - def test_call_retries(self): + async def test_call_retries(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = True @@ -134,17 +133,17 @@ class TestAsyncAsyncSimpleClient: client.client.call = mock.AsyncMock() client.client.call.side_effect = [SocketIOError(), 'result'] - assert _run(client.call('foo', 'bar')) == 'result' + assert await client.call('foo', 'bar') == 'result' client.client.call.assert_awaited_with('foo', 'bar', namespace='/', timeout=60) - def test_receive_with_input_buffer(self): + async def test_receive_with_input_buffer(self): client = AsyncSimpleClient() client.input_buffer = ['foo', 'bar'] - assert _run(client.receive()) == 'foo' - assert _run(client.receive()) == 'bar' + assert await client.receive() == 'foo' + assert await client.receive() == 'bar' - def test_receive_without_input_buffer(self): + async def test_receive_without_input_buffer(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = True @@ -155,9 +154,9 @@ class TestAsyncAsyncSimpleClient: return True client.input_event.wait = fake_wait - assert _run(client.receive()) == 'foo' + assert await client.receive() == 'foo' - def test_receive_with_timeout(self): + async def test_receive_with_timeout(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = True @@ -168,22 +167,22 @@ class TestAsyncAsyncSimpleClient: client.input_event.wait = fake_wait with pytest.raises(TimeoutError): - _run(client.receive(timeout=0.01)) + await client.receive(timeout=0.01) - def test_receive_disconnected(self): + async def test_receive_disconnected(self): client = AsyncSimpleClient() client.connected_event.set() client.connected = False with pytest.raises(DisconnectedError): - _run(client.receive()) + await client.receive() - def test_disconnect(self): + async def test_disconnect(self): client = AsyncSimpleClient() mc = mock.MagicMock() mc.disconnect = mock.AsyncMock() client.client = mc client.connected = True - _run(client.disconnect()) - _run(client.disconnect()) + await client.disconnect() + await client.disconnect() mc.disconnect.assert_awaited_once_with() assert client.client is None diff --git a/tox.ini b/tox.ini index 6d809d4..fc0116c 100644 --- a/tox.ini +++ b/tox.ini @@ -24,6 +24,7 @@ deps= aiohttp msgpack pytest + pytest-asyncio pytest-timeout pytest-cov