final batch of client unit tests

socketio/asyncio_client.py

@@ -143,7 +143,21 @@ class AsyncClient(client.Client):
             id = self._generate_ack_id(namespace, callback)
         else:
             id = None
-        await self._emit_internal(event, data, namespace, id)
+        if six.PY2 and not self.binary:
+            binary = False  # pragma: nocover
+        else:
+            binary = None
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        elif data is not None:
+            data = [data]
+        else:
+            data = []
+        await self._send_packet(packet.Packet(
+            packet.EVENT, namespace=namespace, data=[event] + data, id=id,
+            binary=binary))
 
     async def send(self, data, namespace=None, callback=None):
         """Send a message to one or more connected clients.
@@ -165,7 +179,8 @@ class AsyncClient(client.Client):
 
         Note: this method is a coroutine.
         """
-        await self.emit('message', data, namespace, callback)
+        await self.emit('message', data=data, namespace=namespace,
+                        callback=callback)
 
     async def disconnect(self):
         """Disconnect from the server.
@@ -209,24 +224,6 @@ class AsyncClient(client.Client):
         """
         return await self.eio.sleep(seconds)
 
-    async def _emit_internal(self, event, data, namespace=None, id=None):
-        """Send a message to a client."""
-        if six.PY2 and not self.binary:
-            binary = False  # pragma: nocover
-        else:
-            binary = None
-        # tuples are expanded to multiple arguments, everything else is sent
-        # as a single argument
-        if isinstance(data, tuple):
-            data = list(data)
-        elif data is not None:
-            data = [data]
-        else:
-            data = []
-        await self._send_packet(packet.Packet(
-            packet.EVENT, namespace=namespace, data=[event] + data, id=id,
-            binary=binary))
-
     async def _send_packet(self, pkt):
         """Send a Socket.IO packet to the server."""
         encoded_packet = pkt.encode()
@@ -246,6 +243,8 @@ class AsyncClient(client.Client):
             for n in self.namespaces:
                 await self._send_packet(packet.Packet(packet.CONNECT,
                                         namespace=n))
+        elif namespace not in self.namespaces:
+            self.namespaces.append(namespace)
 
     async def _handle_disconnect(self, namespace):
         namespace = namespace or '/'
@@ -256,9 +255,6 @@ class AsyncClient(client.Client):
     async def _handle_event(self, namespace, id, data):
         namespace = namespace or '/'
         self.logger.info('Received event "%s" [%s]', data[0], namespace)
-        await self._handle_event_internal(data, namespace, id)
-
-    async def _handle_event_internal(self, data, namespace, id):
         r = await self._trigger_event(data[0], namespace, *data[1:])
         if id is not None:
             # send ACK packet with the response returned by the handler
@@ -289,9 +285,12 @@ class AsyncClient(client.Client):
         else:
             del self.callbacks[namespace][id]
         if callback is not None:
-            callback(*data)
+            if asyncio.iscoroutinefunction(callback):
+                await callback(*data)
+            else:
+                callback(*data)
 
-    def _handle_error(self, namespace, data):
+    def _handle_error(self, namespace):
         namespace = namespace or '/'
         self.logger.info('Connection to namespace {} was rejected'.format(
             namespace))
@@ -302,8 +301,7 @@ class AsyncClient(client.Client):
         """Invoke an application event handler."""
         # first see if we have an explicit handler for the event
         if namespace in self.handlers and event in self.handlers[namespace]:
-            if asyncio.iscoroutinefunction(self.handlers[namespace][event]) \
+            if asyncio.iscoroutinefunction(self.handlers[namespace][event]):
-                    is True:
                 try:
                     ret = await self.handlers[namespace][event](*args)
                 except asyncio.CancelledError:  # pragma: no cover
@@ -348,7 +346,7 @@ class AsyncClient(client.Client):
                     'Maximum reconnection attempts reached, giving up')
                 break
 
-    def _handle_eio_connect(self):
+    def _handle_eio_connect(self):  # pragma: no cover
         """Handle the Engine.IO connection event."""
         self.logger.info('Engine.IO connection established')
 
@@ -376,7 +374,7 @@ class AsyncClient(client.Client):
                     pkt.packet_type == packet.BINARY_ACK:
                 self._binary_packet = pkt
             elif pkt.packet_type == packet.ERROR:
-                self._handle_error(pkt.namespace, pkt.data)
+                self._handle_error(pkt.namespace)
             else:
                 raise ValueError('Unknown packet type.')
 

socketio/asyncio_namespace.py

@@ -111,6 +111,28 @@ class AsyncClientNamespace(namespace.ClientNamespace):
     def is_asyncio_based(self):
         return True
 
+    async def trigger_event(self, event, *args):
+        """Dispatch an event to the proper handler method.
+
+        In the most common usage, this method is not overloaded by subclasses,
+        as it performs the routing of events to methods. However, this
+        method can be overriden if special dispatching rules are needed, or if
+        having a single method that catches all events is desired.
+
+        Note: this method is a coroutine.
+        """
+        handler_name = 'on_' + event
+        if hasattr(self, handler_name):
+            handler = getattr(self, handler_name)
+            if asyncio.iscoroutinefunction(handler) is True:
+                try:
+                    ret = await handler(*args)
+                except asyncio.CancelledError:  # pragma: no cover
+                    ret = None
+            else:
+                ret = handler(*args)
+            return ret
+
     async def emit(self, event, data=None, namespace=None, callback=None):
         """Emit a custom event to the server.
 

tests/test_asyncio_client.py

@@ -0,0 +1,621 @@
+import sys
+import unittest
+
+import six
+if six.PY3:
+    from unittest import mock
+else:
+    import mock
+
+from engineio import exceptions as engineio_exceptions
+from socketio import exceptions
+from socketio import packet
+if six.PY3:
+    import asyncio
+    from asyncio import coroutine
+    from socketio import asyncio_client
+    from socketio import asyncio_namespace
+else:
+    # mock coroutine so that Python 2 doesn't complain
+    def coroutine(f):
+        return f
+
+
+def AsyncMock(*args, **kwargs):
+    """Return a mock asynchronous function."""
+    m = mock.MagicMock(*args, **kwargs)
+
+    @coroutine
+    def mock_coro(*args, **kwargs):
+        return m(*args, **kwargs)
+
+    mock_coro.mock = m
+    return mock_coro
+
+
+def _run(coro):
+    """Run the given coroutine."""
+    return asyncio.get_event_loop().run_until_complete(coro)
+
+
+@unittest.skipIf(sys.version_info < (3, 5), 'only for Python 3.5+')
+class TestAsyncClient(unittest.TestCase):
+    def test_is_asyncio_based(self):
+        c = asyncio_client.AsyncClient()
+        self.assertEqual(c.is_asyncio_based(), True)
+
+    def test_connect(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.connect = AsyncMock()
+        _run(c.connect('url', headers='headers', transports='transports',
+                       namespaces=['/foo', '/', '/bar'],
+                       socketio_path='path'))
+        self.assertEqual(c.connection_url, 'url')
+        self.assertEqual(c.connection_headers, 'headers')
+        self.assertEqual(c.connection_transports, 'transports')
+        self.assertEqual(c.connection_namespaces, ['/foo', '/', '/bar'])
+        self.assertEqual(c.socketio_path, 'path')
+        self.assertEqual(c.namespaces, ['/foo', '/bar'])
+        c.eio.connect.mock.assert_called_once_with(
+            'url', headers='headers', transports='transports',
+            engineio_path='path')
+
+    def test_connect_default_namespaces(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.connect = AsyncMock()
+        c.on('foo', mock.MagicMock(), namespace='/foo')
+        c.on('bar', mock.MagicMock(), namespace='/')
+        _run(c.connect('url', headers='headers', transports='transports',
+                       socketio_path='path'))
+        self.assertEqual(c.connection_url, 'url')
+        self.assertEqual(c.connection_headers, 'headers')
+        self.assertEqual(c.connection_transports, 'transports')
+        self.assertEqual(c.connection_namespaces, None)
+        self.assertEqual(c.socketio_path, 'path')
+        self.assertEqual(c.namespaces, ['/foo'])
+        c.eio.connect.mock.assert_called_once_with(
+            'url', headers='headers', transports='transports',
+            engineio_path='path')
+
+    def test_connect_error(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.connect = AsyncMock(
+            side_effect=engineio_exceptions.ConnectionError('foo'))
+        c.on('foo', mock.MagicMock(), namespace='/foo')
+        c.on('bar', mock.MagicMock(), namespace='/')
+        self.assertRaises(
+            exceptions.ConnectionError, _run, c.connect(
+                'url', headers='headers', transports='transports',
+                socketio_path='path'))
+
+    def test_wait_no_reconnect(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.wait = AsyncMock()
+        c.sleep = AsyncMock()
+        c._reconnect_task = None
+        _run(c.wait())
+        c.eio.wait.mock.assert_called_once_with()
+        c.sleep.mock.assert_called_once_with(1)
+
+    def test_wait_reconnect_failed(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.wait = AsyncMock()
+        c.sleep = AsyncMock()
+        states = ['disconnected']
+
+        @coroutine
+        def fake_wait():
+            c.eio.state = states.pop(0)
+
+        c._reconnect_task = fake_wait()
+        _run(c.wait())
+        c.eio.wait.mock.assert_called_once_with()
+        c.sleep.mock.assert_called_once_with(1)
+
+    def test_wait_reconnect_successful(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.wait = AsyncMock()
+        c.sleep = AsyncMock()
+        states = ['connected', 'disconnected']
+
+        @coroutine
+        def fake_wait():
+            c.eio.state = states.pop(0)
+            c._reconnect_task = fake_wait()
+
+        c._reconnect_task = fake_wait()
+        _run(c.wait())
+        self.assertEqual(c.eio.wait.mock.call_count, 2)
+        self.assertEqual(c.sleep.mock.call_count, 2)
+
+    def test_emit_no_arguments(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo'], id=None, binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_one_argument(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', 'bar'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo', 'bar'], id=None,
+                                        binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_one_argument_list(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', ['bar', 'baz']))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo', ['bar', 'baz']], id=None,
+                                        binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_two_arguments(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', ('bar', 'baz')))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo', 'bar', 'baz'], id=None,
+                                        binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_namespace(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', namespace='/foo'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/foo',
+                                        data=['foo'], id=None, binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_with_callback(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        c._generate_ack_id = mock.MagicMock(return_value=123)
+        _run(c.emit('foo', callback='cb'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo'], id=123, binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+        c._generate_ack_id.assert_called_once_with('/', 'cb')
+
+    def test_emit_namespace_with_callback(self):
+        c = asyncio_client.AsyncClient()
+        c._send_packet = AsyncMock()
+        c._generate_ack_id = mock.MagicMock(return_value=123)
+        _run(c.emit('foo', namespace='/foo', callback='cb'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/foo',
+                                        data=['foo'], id=123, binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+        c._generate_ack_id.assert_called_once_with('/foo', 'cb')
+
+    def test_emit_binary(self):
+        c = asyncio_client.AsyncClient(binary=True)
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', b'bar'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo', b'bar'], id=None,
+                                        binary=True)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_emit_not_binary(self):
+        c = asyncio_client.AsyncClient(binary=False)
+        c._send_packet = AsyncMock()
+        _run(c.emit('foo', 'bar'))
+        expected_packet = packet.Packet(packet.EVENT, namespace='/',
+                                        data=['foo', 'bar'], id=None,
+                                        binary=False)
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_send(self):
+        c = asyncio_client.AsyncClient()
+        c.emit = AsyncMock()
+        _run(c.send('data', 'namespace', 'callback'))
+        c.emit.mock.assert_called_once_with(
+            'message', data='data', namespace='namespace',
+            callback='callback')
+
+    def test_send_with_defaults(self):
+        c = asyncio_client.AsyncClient()
+        c.emit = AsyncMock()
+        _run(c.send('data'))
+        c.emit.mock.assert_called_once_with(
+            'message', data='data', namespace=None, callback=None)
+
+    def test_disconnect(self):
+        c = asyncio_client.AsyncClient()
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        _run(c.disconnect())
+        c._trigger_event.mock.assert_called_once_with(
+            'disconnect', namespace='/')
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/')
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_disconnect_namespaces(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        _run(c.disconnect())
+        self.assertEqual(c._trigger_event.mock.call_args_list, [
+            mock.call('disconnect', namespace='/foo'),
+            mock.call('disconnect', namespace='/bar'),
+            mock.call('disconnect', namespace='/')
+        ])
+        self.assertEqual(c._send_packet.mock.call_count, 3)
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo')
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/bar')
+        self.assertEqual(c._send_packet.mock.call_args_list[1][0][0].encode(),
+                         expected_packet.encode())
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/')
+        self.assertEqual(c._send_packet.mock.call_args_list[2][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_start_background_task(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.start_background_task = mock.MagicMock(return_value='foo')
+        self.assertEqual(c.start_background_task('foo', 'bar', baz='baz'),
+                         'foo')
+        c.eio.start_background_task.assert_called_once_with('foo', 'bar',
+                                                            baz='baz')
+
+    def test_sleep(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.sleep = AsyncMock()
+        _run(c.sleep(1.23))
+        c.eio.sleep.mock.assert_called_once_with(1.23)
+
+    def test_send_packet(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.send = AsyncMock()
+        _run(c._send_packet(packet.Packet(packet.EVENT, 'foo', binary=False)))
+        c.eio.send.mock.assert_called_once_with('2"foo"', binary=False)
+
+    def test_send_packet_binary(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.send = AsyncMock()
+        _run(c._send_packet(packet.Packet(packet.EVENT, b'foo', binary=True)))
+        self.assertTrue(c.eio.send.mock.call_args_list == [
+            mock.call('51-{"_placeholder":true,"num":0}', binary=False),
+            mock.call(b'foo', binary=True)
+        ] or c.eio.send.mock.call_args_list == [
+            mock.call('51-{"num":0,"_placeholder":true}', binary=False),
+            mock.call(b'foo', binary=True)
+        ])
+
+    def test_send_packet_default_binary_py3(self):
+        c = asyncio_client.AsyncClient()
+        c.eio.send = AsyncMock()
+        _run(c._send_packet(packet.Packet(packet.EVENT, 'foo')))
+        c.eio.send.mock.assert_called_once_with('2"foo"', binary=False)
+
+    def test_handle_connect(self):
+        c = asyncio_client.AsyncClient()
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        _run(c._handle_connect('/'))
+        c._trigger_event.mock.assert_called_once_with('connect', namespace='/')
+        c._send_packet.mock.assert_not_called()
+
+    def test_handle_connect_with_namespaces(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        _run(c._handle_connect('/'))
+        c._trigger_event.mock.assert_called_once_with('connect', namespace='/')
+        self.assertEqual(c._send_packet.mock.call_count, 2)
+        expected_packet = packet.Packet(packet.CONNECT, namespace='/foo')
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+        expected_packet = packet.Packet(packet.CONNECT, namespace='/bar')
+        self.assertEqual(c._send_packet.mock.call_args_list[1][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_handle_connect_namespace(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo']
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        _run(c._handle_connect('/foo'))
+        _run(c._handle_connect('/bar'))
+        self.assertEqual(c._trigger_event.mock.call_args_list, [
+            mock.call('connect', namespace='/foo'),
+            mock.call('connect', namespace='/bar')
+        ])
+        c._send_packet.mock.assert_not_called()
+        self.assertEqual(c.namespaces, ['/foo', '/bar'])
+
+    def test_handle_disconnect(self):
+        c = asyncio_client.AsyncClient()
+        c._trigger_event = AsyncMock()
+        _run(c._handle_disconnect('/'))
+        c._trigger_event.mock.assert_called_once_with(
+            'disconnect', namespace='/')
+
+    def test_handle_disconnect_namespace(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._trigger_event = AsyncMock()
+        _run(c._handle_disconnect('/foo'))
+        c._trigger_event.mock.assert_called_once_with(
+            'disconnect', namespace='/foo')
+        self.assertEqual(c.namespaces, ['/bar'])
+
+    def test_handle_disconnect_unknown_namespace(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._trigger_event = AsyncMock()
+        _run(c._handle_disconnect('/baz'))
+        c._trigger_event.mock.assert_called_once_with(
+            'disconnect', namespace='/baz')
+        self.assertEqual(c.namespaces, ['/foo', '/bar'])
+
+    def test_handle_event(self):
+        c = asyncio_client.AsyncClient()
+        c._trigger_event = AsyncMock()
+        _run(c._handle_event('/', None, ['foo', ('bar', 'baz')]))
+        c._trigger_event.mock.assert_called_once_with(
+            'foo', '/', ('bar', 'baz'))
+
+    def test_handle_event_with_id_no_arguments(self):
+        c = asyncio_client.AsyncClient(binary=True)
+        c._trigger_event = AsyncMock(return_value=None)
+        c._send_packet = AsyncMock()
+        _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')]))
+        c._trigger_event.mock.assert_called_once_with(
+            'foo', '/', ('bar', 'baz'))
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        expected_packet = packet.Packet(packet.ACK, namespace='/', id=123,
+                                        data=[], binary=None)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_handle_event_with_id_one_argument(self):
+        c = asyncio_client.AsyncClient(binary=True)
+        c._trigger_event = AsyncMock(return_value='ret')
+        c._send_packet = AsyncMock()
+        _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')]))
+        c._trigger_event.mock.assert_called_once_with(
+            'foo', '/', ('bar', 'baz'))
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        expected_packet = packet.Packet(packet.ACK, namespace='/', id=123,
+                                        data=['ret'], binary=None)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_handle_event_with_id_one_list_argument(self):
+        c = asyncio_client.AsyncClient(binary=True)
+        c._trigger_event = AsyncMock(return_value=['a', 'b'])
+        c._send_packet = AsyncMock()
+        _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')]))
+        c._trigger_event.mock.assert_called_once_with(
+            'foo', '/', ('bar', 'baz'))
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        expected_packet = packet.Packet(packet.ACK, namespace='/', id=123,
+                                        data=[['a', 'b']], binary=None)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_handle_event_with_id_two_arguments(self):
+        c = asyncio_client.AsyncClient(binary=True)
+        c._trigger_event = AsyncMock(return_value=('a', 'b'))
+        c._send_packet = AsyncMock()
+        _run(c._handle_event('/', 123, ['foo', ('bar', 'baz')]))
+        c._trigger_event.mock.assert_called_once_with(
+            'foo', '/', ('bar', 'baz'))
+        self.assertEqual(c._send_packet.mock.call_count, 1)
+        expected_packet = packet.Packet(packet.ACK, namespace='/', id=123,
+                                        data=['a', 'b'], binary=None)
+        self.assertEqual(c._send_packet.mock.call_args_list[0][0][0].encode(),
+                         expected_packet.encode())
+
+    def test_handle_ack(self):
+        c = asyncio_client.AsyncClient()
+        mock_cb = mock.MagicMock()
+        c.callbacks['/foo'] = {123: mock_cb}
+        _run(c._handle_ack('/foo', 123, ['bar', 'baz']))
+        mock_cb.assert_called_once_with('bar', 'baz')
+        self.assertNotIn(123, c.callbacks['/foo'])
+
+    def test_handle_ack_async(self):
+        c = asyncio_client.AsyncClient()
+        mock_cb = AsyncMock()
+        c.callbacks['/foo'] = {123: mock_cb}
+        _run(c._handle_ack('/foo', 123, ['bar', 'baz']))
+        mock_cb.mock.assert_called_once_with('bar', 'baz')
+        self.assertNotIn(123, c.callbacks['/foo'])
+
+    def test_handle_ack_not_found(self):
+        c = asyncio_client.AsyncClient()
+        mock_cb = mock.MagicMock()
+        c.callbacks['/foo'] = {123: mock_cb}
+        _run(c._handle_ack('/foo', 124, ['bar', 'baz']))
+        mock_cb.assert_not_called()
+        self.assertIn(123, c.callbacks['/foo'])
+
+    def test_handle_error(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._handle_error('/bar')
+        self.assertEqual(c.namespaces, ['/foo'])
+
+    def test_handle_error_unknown_namespace(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._handle_error('/baz')
+        self.assertEqual(c.namespaces, ['/foo', '/bar'])
+
+    def test_trigger_event(self):
+        c = asyncio_client.AsyncClient()
+        handler = mock.MagicMock()
+        c.on('foo', handler)
+        _run(c._trigger_event('foo', '/', 1, '2'))
+        handler.assert_called_once_with(1, '2')
+
+    def test_trigger_event_namespace(self):
+        c = asyncio_client.AsyncClient()
+        handler = AsyncMock()
+        c.on('foo', handler, namespace='/bar')
+        _run(c._trigger_event('foo', '/bar', 1, '2'))
+        handler.mock.assert_called_once_with(1, '2')
+
+    def test_trigger_event_class_namespace(self):
+        c = asyncio_client.AsyncClient()
+        result = []
+
+        class MyNamespace(asyncio_namespace.AsyncClientNamespace):
+            def on_foo(self, a, b):
+                result.append(a)
+                result.append(b)
+
+        c.register_namespace(MyNamespace('/'))
+        _run(c._trigger_event('foo', '/', 1, '2'))
+        self.assertEqual(result, [1, '2'])
+
+    @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5])
+    def test_handle_reconnect(self, random):
+        c = asyncio_client.AsyncClient()
+        c._reconnect_task = 'foo'
+        c.sleep = AsyncMock()
+        c.connect = AsyncMock(
+            side_effect=[ValueError, exceptions.ConnectionError, None])
+        _run(c._handle_reconnect())
+        self.assertEqual(c.sleep.mock.call_count, 3)
+        self.assertEqual(c.sleep.mock.call_args_list, [
+            mock.call(1.5),
+            mock.call(1.5),
+            mock.call(4.0)
+        ])
+        self.assertEqual(c._reconnect_task, None)
+
+    @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5])
+    def test_handle_reconnect_max_delay(self, random):
+        c = asyncio_client.AsyncClient(reconnection_delay_max=3)
+        c._reconnect_task = 'foo'
+        c.sleep = AsyncMock()
+        c.connect = AsyncMock(
+            side_effect=[ValueError, exceptions.ConnectionError, None])
+        _run(c._handle_reconnect())
+        self.assertEqual(c.sleep.mock.call_count, 3)
+        self.assertEqual(c.sleep.mock.call_args_list, [
+            mock.call(1.5),
+            mock.call(1.5),
+            mock.call(3.0)
+        ])
+        self.assertEqual(c._reconnect_task, None)
+
+    @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5])
+    def test_handle_reconnect_max_attempts(self, random):
+        c = asyncio_client.AsyncClient(reconnection_attempts=2)
+        c._reconnect_task = 'foo'
+        c.sleep = AsyncMock()
+        c.connect = AsyncMock(
+            side_effect=[ValueError, exceptions.ConnectionError, None])
+        _run(c._handle_reconnect())
+        self.assertEqual(c.sleep.mock.call_count, 2)
+        self.assertEqual(c.sleep.mock.call_args_list, [
+            mock.call(1.5),
+            mock.call(1.5)
+        ])
+        self.assertEqual(c._reconnect_task, 'foo')
+
+    def test_handle_eio_message(self):
+        c = asyncio_client.AsyncClient()
+        c._handle_connect = AsyncMock()
+        c._handle_disconnect = AsyncMock()
+        c._handle_event = AsyncMock()
+        c._handle_ack = AsyncMock()
+        c._handle_error = mock.MagicMock()
+
+        _run(c._handle_eio_message('0'))
+        c._handle_connect.mock.assert_called_with(None)
+        _run(c._handle_eio_message('0/foo'))
+        c._handle_connect.mock.assert_called_with('/foo')
+        _run(c._handle_eio_message('1'))
+        c._handle_disconnect.mock.assert_called_with(None)
+        _run(c._handle_eio_message('1/foo'))
+        c._handle_disconnect.mock.assert_called_with('/foo')
+        _run(c._handle_eio_message('2["foo"]'))
+        c._handle_event.mock.assert_called_with(None, None, ['foo'])
+        _run(c._handle_eio_message('3/foo,["bar"]'))
+        c._handle_ack.mock.assert_called_with('/foo', None, ['bar'])
+        _run(c._handle_eio_message('4'))
+        c._handle_error.assert_called_with(None)
+        _run(c._handle_eio_message('4/foo'))
+        c._handle_error.assert_called_with('/foo')
+        _run(c._handle_eio_message('51-{"_placeholder":true,"num":0}'))
+        self.assertEqual(c._binary_packet.packet_type, packet.BINARY_EVENT)
+        _run(c._handle_eio_message(b'foo'))
+        c._handle_event.mock.assert_called_with(None, None, b'foo')
+        _run(c._handle_eio_message(
+            '62-/foo,{"1":{"_placeholder":true,"num":1},'
+            '"2":{"_placeholder":true,"num":0}}'))
+        self.assertEqual(c._binary_packet.packet_type, packet.BINARY_ACK)
+        _run(c._handle_eio_message(b'bar'))
+        _run(c._handle_eio_message(b'foo'))
+        c._handle_ack.mock.assert_called_with('/foo', None, {'1': b'foo',
+                                                             '2': b'bar'})
+        self.assertRaises(ValueError, _run, c._handle_eio_message('9'))
+
+    def test_eio_disconnect(self):
+        c = asyncio_client.AsyncClient()
+        c._trigger_event = AsyncMock()
+        _run(c._handle_eio_disconnect())
+        c._trigger_event.mock.assert_called_once_with(
+            'disconnect', namespace='/')
+
+    def test_eio_disconnect_namespaces(self):
+        c = asyncio_client.AsyncClient()
+        c.namespaces = ['/foo', '/bar']
+        c._trigger_event = AsyncMock()
+        _run(c._handle_eio_disconnect())
+        c._trigger_event.mock.assert_any_call('disconnect', namespace='/foo')
+        c._trigger_event.mock.assert_any_call('disconnect', namespace='/bar')
+        c._trigger_event.mock.assert_any_call('disconnect', namespace='/')
+
+    def test_eio_disconnect_reconnect(self):
+        c = asyncio_client.AsyncClient(reconnection=True)
+        c.start_background_task = mock.MagicMock()
+        c.eio.state = 'connected'
+        _run(c._handle_eio_disconnect())
+        c.start_background_task.assert_called_once_with(c._handle_reconnect)
+
+    def test_eio_disconnect_self_disconnect(self):
+        c = asyncio_client.AsyncClient(reconnection=True)
+        c.start_background_task = mock.MagicMock()
+        c.eio.state = 'disconnected'
+        _run(c._handle_eio_disconnect())
+        c.start_background_task.assert_not_called()
+
+    def test_eio_disconnect_no_reconnect(self):
+        c = asyncio_client.AsyncClient(reconnection=False)
+        c.start_background_task = mock.MagicMock()
+        c.eio.state = 'connected'
+        _run(c._handle_eio_disconnect())
+        c.start_background_task.assert_not_called()

tests/test_asyncio_namespace.py

@@ -180,6 +180,45 @@ class TestAsyncNamespace(unittest.TestCase):
         _run(ns.disconnect('sid', namespace='/bar'))
         ns.server.disconnect.mock.assert_called_with('sid', namespace='/bar')
 
+    def test_sync_event_client(self):
+        result = {}
+
+        class MyNamespace(asyncio_namespace.AsyncClientNamespace):
+            def on_custom_message(self, sid, data):
+                result['result'] = (sid, data)
+
+        ns = MyNamespace('/foo')
+        ns._set_client(mock.MagicMock())
+        _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'}))
+        self.assertEqual(result['result'], ('sid', {'data': 'data'}))
+
+    def test_async_event_client(self):
+        result = {}
+
+        class MyNamespace(asyncio_namespace.AsyncClientNamespace):
+            @coroutine
+            def on_custom_message(self, sid, data):
+                result['result'] = (sid, data)
+
+        ns = MyNamespace('/foo')
+        ns._set_client(mock.MagicMock())
+        _run(ns.trigger_event('custom_message', 'sid', {'data': 'data'}))
+        self.assertEqual(result['result'], ('sid', {'data': 'data'}))
+
+    def test_event_not_found_client(self):
+        result = {}
+
+        class MyNamespace(asyncio_namespace.AsyncClientNamespace):
+            @coroutine
+            def on_custom_message(self, sid, data):
+                result['result'] = (sid, data)
+
+        ns = MyNamespace('/foo')
+        ns._set_client(mock.MagicMock())
+        _run(ns.trigger_event('another_custom_message', 'sid',
+                              {'data': 'data'}))
+        self.assertEqual(result, {})
+
     def test_emit_client(self):
         ns = asyncio_namespace.AsyncClientNamespace('/foo')
         mock_client = mock.MagicMock()

tests/test_client.py

@@ -21,7 +21,7 @@ from socketio import namespace
 from socketio import packet
 
 
-class TesClient(unittest.TestCase):
+class TestClient(unittest.TestCase):
     def test_is_asyncio_based(self):
         c = client.Client()
         self.assertEqual(c.is_asyncio_based(), False)
@@ -593,8 +593,8 @@ class TesClient(unittest.TestCase):
         c = client.Client()
         c._reconnect_task = 'foo'
         c.sleep = mock.MagicMock()
-        c.connect = mock.MagicMock(side_effect=[ValueError,
+        c.connect = mock.MagicMock(
-                                   exceptions.ConnectionError, None])
+            side_effect=[ValueError, exceptions.ConnectionError, None])
         c._handle_reconnect()
         self.assertEqual(c.sleep.call_count, 3)
         self.assertEqual(c.sleep.call_args_list, [
@@ -609,8 +609,8 @@ class TesClient(unittest.TestCase):
         c = client.Client(reconnection_delay_max=3)
         c._reconnect_task = 'foo'
         c.sleep = mock.MagicMock()
-        c.connect = mock.MagicMock(side_effect=[ValueError,
+        c.connect = mock.MagicMock(
-                                   exceptions.ConnectionError, None])
+            side_effect=[ValueError, exceptions.ConnectionError, None])
         c._handle_reconnect()
         self.assertEqual(c.sleep.call_count, 3)
         self.assertEqual(c.sleep.call_args_list, [
@@ -625,8 +625,8 @@ class TesClient(unittest.TestCase):
         c = client.Client(reconnection_attempts=2)
         c._reconnect_task = 'foo'
         c.sleep = mock.MagicMock()
-        c.connect = mock.MagicMock(side_effect=[ValueError,
+        c.connect = mock.MagicMock(
-                                   exceptions.ConnectionError, None])
+            side_effect=[ValueError, exceptions.ConnectionError, None])
         c._handle_reconnect()
         self.assertEqual(c.sleep.call_count, 2)
         self.assertEqual(c.sleep.call_args_list, [