mirror
/
miguelgrinberg.python-socketio
mirror of https://github.com/miguelgrinberg/python-socketio
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

v5 protocol: server unit tests

pull/599/head
Miguel Grinberg 5 years ago
parent
0c91e92eb1
commit
0ecfbf593d
No known key found for this signature in database GPG Key ID: 36848B262DF5F06C
5 changed files with 330 additions and 331 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 18
      socketio/asyncio_server.py
  2. 3
      socketio/base_manager.py
  3. 21
      socketio/server.py
  4. 326
      tests/asyncio/test_asyncio_server.py
  5. 293
      tests/common/test_server.py

18
socketio/asyncio_server.py
View File

@ -423,15 +423,11 @@ class AsyncServer(server.Server):
self.manager.pre_disconnect(sid, namespace) self.manager.pre_disconnect(sid, namespace)
await self._send_packet(eio_sid, packet.Packet( await self._send_packet(eio_sid, packet.Packet(
packet.DISCONNECT, data=fail_reason, namespace=namespace)) packet.DISCONNECT, data=fail_reason, namespace=namespace))
elif namespace != '/': else:
await self._send_packet(eio_sid, packet.Packet( await self._send_packet(eio_sid, packet.Packet(
packet.CONNECT_ERROR, data=fail_reason, packet.CONNECT_ERROR, data=fail_reason,
namespace=namespace)) namespace=namespace))
self.manager.disconnect(sid, namespace) self.manager.disconnect(sid, namespace)
if namespace == '/' and \
eio_sid in self.environ: # pragma: no cover
del self.environ[eio_sid]
return fail_reason or False
elif not self.always_connect: elif not self.always_connect:
await self._send_packet(eio_sid, packet.Packet( await self._send_packet(eio_sid, packet.Packet(
packet.CONNECT, {'sid': sid}, namespace=namespace)) packet.CONNECT, {'sid': sid}, namespace=namespace))
@ -440,10 +436,11 @@ class AsyncServer(server.Server):
"""Handle a client disconnect.""" """Handle a client disconnect."""
namespace = namespace or '/' namespace = namespace or '/'
sid = self.manager.sid_from_eio_sid(eio_sid, namespace) sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
if self.manager.is_connected(sid, namespace): if not self.manager.is_connected(sid, namespace): # pragma: no cover
self.manager.pre_disconnect(sid, namespace=namespace) return
await self._trigger_event('disconnect', namespace, sid) self.manager.pre_disconnect(sid, namespace=namespace)
self.manager.disconnect(sid, namespace) await self._trigger_event('disconnect', namespace, sid)
self.manager.disconnect(sid, namespace)
async def _handle_event(self, eio_sid, namespace, id, data): async def _handle_event(self, eio_sid, namespace, id, data):
"""Handle an incoming client event.""" """Handle an incoming client event."""
@ -544,7 +541,8 @@ class AsyncServer(server.Server):
async def _handle_eio_disconnect(self, eio_sid): async def _handle_eio_disconnect(self, eio_sid):
"""Handle Engine.IO disconnect event.""" """Handle Engine.IO disconnect event."""
await self._handle_disconnect(eio_sid, '/') for n in list(self.manager.get_namespaces()).copy():
await self._handle_disconnect(eio_sid, n)
if eio_sid in self.environ: if eio_sid in self.environ:
del self.environ[eio_sid] del self.environ[eio_sid]

3
socketio/base_manager.py
View File

@ -60,7 +60,8 @@ class BaseManager(object):
pass pass
def sid_from_eio_sid(self, eio_sid, namespace): def sid_from_eio_sid(self, eio_sid, namespace):
return self.rooms[namespace][None].inverse.get(eio_sid) if namespace in self.rooms:
return self.rooms[namespace][None].inverse.get(eio_sid)
def can_disconnect(self, sid, namespace): def can_disconnect(self, sid, namespace):
return self.is_connected(sid, namespace) return self.is_connected(sid, namespace)

21
socketio/server.py
View File

@ -116,8 +116,7 @@ class Server(object):
self.logger = logger self.logger = logger
else: else:
self.logger = default_logger self.logger = default_logger
if not logging.root.handlers and \ if self.logger.level == logging.NOTSET:
self.logger.level == logging.NOTSET:
if logger: if logger:
self.logger.setLevel(logging.INFO) self.logger.setLevel(logging.INFO)
else: else:
@ -621,15 +620,11 @@ class Server(object):
self.manager.pre_disconnect(sid, namespace) self.manager.pre_disconnect(sid, namespace)
self._send_packet(eio_sid, packet.Packet( self._send_packet(eio_sid, packet.Packet(
packet.DISCONNECT, data=fail_reason, namespace=namespace)) packet.DISCONNECT, data=fail_reason, namespace=namespace))
elif namespace != '/': else:
self._send_packet(eio_sid, packet.Packet( self._send_packet(eio_sid, packet.Packet(
packet.CONNECT_ERROR, data=fail_reason, packet.CONNECT_ERROR, data=fail_reason,
namespace=namespace)) namespace=namespace))
self.manager.disconnect(sid, namespace) self.manager.disconnect(sid, namespace)
if namespace == '/' and \
eio_sid in self.environ: # pragma: no cover
del self.environ[eio_sid]
return fail_reason or False
elif not self.always_connect: elif not self.always_connect:
self._send_packet(eio_sid, packet.Packet( self._send_packet(eio_sid, packet.Packet(
packet.CONNECT, {'sid': sid}, namespace=namespace)) packet.CONNECT, {'sid': sid}, namespace=namespace))
@ -638,10 +633,11 @@ class Server(object):
"""Handle a client disconnect.""" """Handle a client disconnect."""
namespace = namespace or '/' namespace = namespace or '/'
sid = self.manager.sid_from_eio_sid(eio_sid, namespace) sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
if self.manager.is_connected(sid, namespace): if not self.manager.is_connected(sid, namespace): # pragma: no cover
self.manager.pre_disconnect(sid, namespace=namespace) return
self._trigger_event('disconnect', namespace, sid) self.manager.pre_disconnect(sid, namespace=namespace)
self.manager.disconnect(sid, namespace) self._trigger_event('disconnect', namespace, sid)
self.manager.disconnect(sid, namespace)
def _handle_event(self, eio_sid, namespace, id, data): def _handle_event(self, eio_sid, namespace, id, data):
"""Handle an incoming client event.""" """Handle an incoming client event."""
@ -731,7 +727,8 @@ class Server(object):
def _handle_eio_disconnect(self, eio_sid): def _handle_eio_disconnect(self, eio_sid):
"""Handle Engine.IO disconnect event.""" """Handle Engine.IO disconnect event."""
self._handle_disconnect(eio_sid, '/') for n in list(self.manager.get_namespaces()).copy():
self._handle_disconnect(eio_sid, n)
if eio_sid in self.environ: if eio_sid in self.environ:
del self.environ[eio_sid] del self.environ[eio_sid]

326
tests/asyncio/test_asyncio_server.py
View File

@ -36,7 +36,8 @@ def _run(coro):
@unittest.skipIf(sys.version_info < (3, 5), 'only for Python 3.5+') @unittest.skipIf(sys.version_info < (3, 5), 'only for Python 3.5+')
@mock.patch('socketio.server.engineio.AsyncServer') @mock.patch('socketio.server.engineio.AsyncServer', **{
'return_value.generate_id.side_effect': [str(i) for i in range(1, 10)]})
class TestAsyncServer(unittest.TestCase): class TestAsyncServer(unittest.TestCase):
def tearDown(self): def tearDown(self):
# restore JSON encoder, in case a test changed it # restore JSON encoder, in case a test changed it
@ -61,7 +62,6 @@ class TestAsyncServer(unittest.TestCase):
eio.assert_called_once_with(**{'foo': 'bar', 'async_handlers': False}) eio.assert_called_once_with(**{'foo': 'bar', 'async_handlers': False})
assert s.manager == mgr assert s.manager == mgr
assert s.eio.on.call_count == 3 assert s.eio.on.call_count == 3
assert not s.binary
assert s.async_handlers assert s.async_handlers
def test_attach(self, eio): def test_attach(self, eio):
@ -296,7 +296,7 @@ class TestAsyncServer(unittest.TestCase):
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', 'my data', namespace='/foo')) _run(s._emit_internal('123', 'my event', 'my data', namespace='/foo'))
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event","my data"]', binary=False '123', '2/foo,["my event","my data"]'
) )
def test_emit_internal_with_tuple(self, eio): def test_emit_internal_with_tuple(self, eio):
@ -308,7 +308,7 @@ class TestAsyncServer(unittest.TestCase):
) )
) )
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event","foo","bar"]', binary=False '123', '2/foo,["my event","foo","bar"]'
) )
def test_emit_internal_with_list(self, eio): def test_emit_internal_with_list(self, eio):
@ -320,7 +320,7 @@ class TestAsyncServer(unittest.TestCase):
) )
) )
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event",["foo","bar"]]', binary=False '123', '2/foo,["my event",["foo","bar"]]'
) )
def test_emit_internal_with_none(self, eio): def test_emit_internal_with_none(self, eio):
@ -328,20 +328,20 @@ class TestAsyncServer(unittest.TestCase):
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', None, namespace='/foo')) _run(s._emit_internal('123', 'my event', None, namespace='/foo'))
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event"]', binary=False '123', '2/foo,["my event"]'
) )
def test_emit_internal_with_callback(self, eio): def test_emit_internal_with_callback(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
id = s.manager._generate_ack_id('123', '/foo', 'cb') id = s.manager._generate_ack_id('1', 'cb')
_run( _run(
s._emit_internal( s._emit_internal(
'123', 'my event', 'my data', namespace='/foo', id=id '123', 'my event', 'my data', namespace='/foo', id=id
) )
) )
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2/foo,1["my event","my data"]', binary=False '123', '2/foo,1["my event","my data"]'
) )
def test_emit_internal_default_namespace(self, eio): def test_emit_internal_default_namespace(self, eio):
@ -349,7 +349,7 @@ class TestAsyncServer(unittest.TestCase):
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', 'my data')) _run(s._emit_internal('123', 'my event', 'my data'))
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '2["my event","my data"]', binary=False '123', '2["my event","my data"]'
) )
def test_emit_internal_binary(self, eio): def test_emit_internal_binary(self, eio):
@ -368,180 +368,186 @@ class TestAsyncServer(unittest.TestCase):
def test_handle_connect(self, eio): def test_handle_connect(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr) s.manager.initialize = mock.MagicMock()
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('connect', handler) s.on('connect', handler)
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
handler.assert_called_once_with('123', 'environ') _run(s._handle_eio_message('123', '0'))
s.manager.connect.assert_called_once_with('123', '/') assert s.manager.is_connected('1', '/')
s.eio.send.mock.assert_called_once_with('123', '0', binary=False) handler.assert_called_once_with('1', 'environ')
assert mgr.initialize.call_count == 1 s.eio.send.mock.assert_called_once_with('123', '0{"sid":"1"}')
assert s.manager.initialize.call_count == 1
_run(s._handle_eio_connect('456', 'environ')) _run(s._handle_eio_connect('456', 'environ'))
assert mgr.initialize.call_count == 1 _run(s._handle_eio_message('456', '0'))
assert s.manager.initialize.call_count == 1
def test_handle_connect_async(self, eio): def test_handle_connect_async(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr) s.manager.initialize = mock.MagicMock()
handler = AsyncMock() handler = AsyncMock()
s.on('connect', handler) s.on('connect', handler)
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
handler.mock.assert_called_once_with('123', 'environ') _run(s._handle_eio_message('123', '0'))
s.manager.connect.assert_called_once_with('123', '/') assert s.manager.is_connected('1', '/')
s.eio.send.mock.assert_called_once_with('123', '0', binary=False) handler.mock.assert_called_once_with('1', 'environ')
assert mgr.initialize.call_count == 1 s.eio.send.mock.assert_called_once_with('123', '0{"sid":"1"}')
assert s.manager.initialize.call_count == 1
_run(s._handle_eio_connect('456', 'environ')) _run(s._handle_eio_connect('456', 'environ'))
assert mgr.initialize.call_count == 1 _run(s._handle_eio_message('456', '0'))
assert s.manager.initialize.call_count == 1
def test_handle_connect_namespace(self, eio): def test_handle_connect_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
handler.assert_called_once_with('123', 'environ') assert s.manager.is_connected('1', '/foo')
s.manager.connect.assert_any_call('123', '/') handler.assert_called_once_with('1', 'environ')
s.manager.connect.assert_any_call('123', '/foo') s.eio.send.mock.assert_called_once_with('123', '0/foo,{"sid":"1"}')
s.eio.send.mock.assert_any_call('123', '0/foo', binary=False)
def test_handle_connect_always_connect(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_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'))
assert s.manager.is_connected('1', '/')
handler.assert_called_once_with('1', 'environ')
s.eio.send.mock.assert_called_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'))
assert s.manager.initialize.call_count == 1
def test_handle_connect_rejected(self, eio): def test_handle_connect_rejected(self, eio):
mgr = self._get_mock_manager() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(client_manager=mgr) s = asyncio_server.AsyncServer()
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler) s.on('connect', handler)
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
assert not ret _run(s._handle_eio_message('123', '0'))
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_called_once_with('123', '4')
assert s.environ == {} assert s.environ == {'123': 'environ'}
def test_handle_connect_namespace_rejected(self, eio): def test_handle_connect_namespace_rejected(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_any_call('123', '4/foo')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.mock.assert_any_call('123', '4/foo', binary=False)
def test_handle_connect_rejected_always_connect(self, eio): def test_handle_connect_rejected_always_connect(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(always_connect=True)
s = asyncio_server.AsyncServer(client_manager=mgr, always_connect=True)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler) s.on('connect', handler)
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
assert not ret _run(s._handle_eio_message('123', '0'))
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_any_call('123', '0{"sid":"1"}')
assert s.environ == {} s.eio.send.mock.assert_any_call('123', '1')
s.eio.send.mock.assert_any_call('123', '0', binary=False) assert s.environ == {'123': 'environ'}
s.eio.send.mock.assert_any_call('123', '1', binary=False)
def test_handle_connect_namespace_rejected_always_connect(self, eio): def test_handle_connect_namespace_rejected_always_connect(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(always_connect=True)
s = asyncio_server.AsyncServer(client_manager=mgr, always_connect=True)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
assert not ret assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_any_call('123', '0/foo,{"sid":"1"}')
s.eio.send.mock.assert_any_call('123', '1/foo')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.mock.assert_any_call('123', '0/foo', binary=False)
s.eio.send.mock.assert_any_call('123', '1/foo', binary=False)
def test_handle_connect_rejected_with_exception(self, eio): def test_handle_connect_rejected_with_exception(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError('fail_reason') side_effect=exceptions.ConnectionRefusedError('fail_reason')
) )
s.on('connect', handler) s.on('connect', handler)
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
assert ret == 'fail_reason' _run(s._handle_eio_message('123', '0'))
assert s.manager.connect.call_count == 1 assert not s.manager.is_connected('1', '/')
assert s.manager.disconnect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.environ == {} s.eio.send.mock.assert_called_once_with('123', '4"fail_reason"')
assert s.environ == {'123': 'environ'}
def test_handle_connect_rejected_with_empty_exception(self, eio): def test_handle_connect_rejected_with_empty_exception(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError() side_effect=exceptions.ConnectionRefusedError()
) )
s.on('connect', handler) s.on('connect', handler)
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
assert not ret _run(s._handle_eio_message('123', '0'))
assert s.manager.connect.call_count == 1 assert not s.manager.is_connected('1', '/')
assert s.manager.disconnect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.environ == {} s.eio.send.mock.assert_called_once_with('123', '4')
assert s.environ == {'123': 'environ'}
def test_handle_connect_namespace_rejected_with_exception(self, eio): def test_handle_connect_namespace_rejected_with_exception(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError('fail_reason', 1) side_effect=exceptions.ConnectionRefusedError('fail_reason', 1)
) )
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_called_once_with('123',
'4/foo,["fail_reason",1]')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.mock.assert_any_call(
'123', '4/foo,["fail_reason",1]', binary=False
)
def test_handle_connect_namespace_rejected_with_empty_exception(self, eio): def test_handle_connect_namespace_rejected_with_empty_exception(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError() side_effect=exceptions.ConnectionRefusedError()
) )
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = _run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.mock.assert_called_once_with('123', '4/foo')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.mock.assert_any_call('123', '4/foo', binary=False)
def test_handle_disconnect(self, eio): def test_handle_disconnect(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr) s.manager.disconnect = mock.MagicMock()
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0'))
_run(s._handle_eio_disconnect('123')) _run(s._handle_eio_disconnect('123'))
handler.assert_called_once_with('123') handler.assert_called_once_with('1')
s.manager.disconnect.assert_called_once_with('123', '/') s.manager.disconnect.assert_called_once_with('1', '/')
assert s.environ == {} assert s.environ == {}
def test_handle_disconnect_namespace(self, eio): def test_handle_disconnect_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
s.manager.get_namespaces = mock.MagicMock(return_value=['/', '/foo'])
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
handler_namespace = mock.MagicMock() handler_namespace = mock.MagicMock()
@ -549,15 +555,13 @@ class TestAsyncServer(unittest.TestCase):
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
_run(s._handle_eio_disconnect('123')) _run(s._handle_eio_disconnect('123'))
handler.assert_called_once_with('123') handler.assert_not_called()
handler_namespace.assert_called_once_with('123') handler_namespace.assert_called_once_with('1')
assert s.environ == {} assert s.environ == {}
def test_handle_disconnect_only_namespace(self, eio): def test_handle_disconnect_only_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer()
s = asyncio_server.AsyncServer(client_manager=mgr)
s.manager.get_namespaces = mock.MagicMock(return_value=['/', '/foo'])
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
handler_namespace = mock.MagicMock() handler_namespace = mock.MagicMock()
@ -566,7 +570,7 @@ class TestAsyncServer(unittest.TestCase):
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
_run(s._handle_eio_message('123', '1/foo')) _run(s._handle_eio_message('123', '1/foo'))
assert handler.call_count == 0 assert handler.call_count == 0
handler_namespace.assert_called_once_with('123') handler_namespace.assert_called_once_with('1')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
def test_handle_disconnect_unknown_client(self, eio): def test_handle_disconnect_unknown_client(self, eio):
@ -577,20 +581,20 @@ class TestAsyncServer(unittest.TestCase):
def test_handle_event(self, eio): def test_handle_event(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(async_handlers=False) s = asyncio_server.AsyncServer(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = AsyncMock() handler = AsyncMock()
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '2["my message","a","b","c"]')) _run(s._handle_eio_message('123', '2["my message","a","b","c"]'))
handler.mock.assert_called_once_with('123', 'a', 'b', 'c') handler.mock.assert_called_once_with(sid, 'a', 'b', 'c')
def test_handle_event_with_namespace(self, eio): def test_handle_event_with_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(async_handlers=False) s = asyncio_server.AsyncServer(async_handlers=False)
s.manager.connect('123', '/foo') sid = s.manager.connect('123', '/foo')
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('my message', handler, namespace='/foo') s.on('my message', handler, namespace='/foo')
_run(s._handle_eio_message('123', '2/foo,["my message","a","b","c"]')) _run(s._handle_eio_message('123', '2/foo,["my message","a","b","c"]'))
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with(sid, 'a', 'b', 'c')
def test_handle_event_with_disconnected_namespace(self, eio): def test_handle_event_with_disconnected_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
@ -604,7 +608,7 @@ class TestAsyncServer(unittest.TestCase):
def test_handle_event_binary(self, eio): def test_handle_event_binary(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(async_handlers=False) s = asyncio_server.AsyncServer(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('my message', handler) s.on('my message', handler)
_run( _run(
@ -617,15 +621,13 @@ class TestAsyncServer(unittest.TestCase):
) )
_run(s._handle_eio_message('123', b'foo')) _run(s._handle_eio_message('123', b'foo'))
_run(s._handle_eio_message('123', b'bar')) _run(s._handle_eio_message('123', b'bar'))
handler.assert_called_once_with('123', 'a', b'bar', b'foo') handler.assert_called_once_with(sid, 'a', b'bar', b'foo')
def test_handle_event_binary_ack(self, eio): def test_handle_event_binary_ack(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(async_handlers=False)
s = asyncio_server.AsyncServer( s.manager.trigger_callback = AsyncMock()
client_manager=mgr, async_handlers=False sid = s.manager.connect('123', '/')
)
s.manager.initialize(s)
_run( _run(
s._handle_eio_message( s._handle_eio_message(
'123', '123',
@ -633,70 +635,64 @@ class TestAsyncServer(unittest.TestCase):
) )
) )
_run(s._handle_eio_message('123', b'foo')) _run(s._handle_eio_message('123', b'foo'))
mgr.trigger_callback.mock.assert_called_once_with( s.manager.trigger_callback.mock.assert_called_once_with(
'123', '/', 321, ['my message', 'a', b'foo'] sid, 321, ['my message', 'a', b'foo']
) )
def test_handle_event_with_ack(self, eio): def test_handle_event_with_ack(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(async_handlers=False) s = asyncio_server.AsyncServer(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = mock.MagicMock(return_value='foo') handler = mock.MagicMock(return_value='foo')
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '21000["my message","foo"]')) _run(s._handle_eio_message('123', '21000["my message","foo"]'))
handler.assert_called_once_with('123', 'foo') handler.assert_called_once_with(sid, 'foo')
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '31000["foo"]', binary=False '123', '31000["foo"]'
) )
def test_handle_event_with_ack_none(self, eio): def test_handle_event_with_ack_none(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer(async_handlers=False) s = asyncio_server.AsyncServer(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = mock.MagicMock(return_value=None) handler = mock.MagicMock(return_value=None)
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '21000["my message","foo"]')) _run(s._handle_eio_message('123', '21000["my message","foo"]'))
handler.assert_called_once_with('123', 'foo') handler.assert_called_once_with(sid, 'foo')
s.eio.send.mock.assert_called_once_with('123', '31000[]', binary=False) s.eio.send.mock.assert_called_once_with('123', '31000[]')
def test_handle_event_with_ack_tuple(self, eio): def test_handle_event_with_ack_tuple(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(async_handlers=False)
s = asyncio_server.AsyncServer( sid = s.manager.connect('123', '/')
client_manager=mgr, async_handlers=False
)
handler = mock.MagicMock(return_value=(1, '2', True)) handler = mock.MagicMock(return_value=(1, '2', True))
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '21000["my message","a","b","c"]')) _run(s._handle_eio_message('123', '21000["my message","a","b","c"]'))
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with(sid, 'a', 'b', 'c')
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '31000[1,"2",true]', binary=False '123', '31000[1,"2",true]'
) )
def test_handle_event_with_ack_list(self, eio): def test_handle_event_with_ack_list(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(async_handlers=False)
s = asyncio_server.AsyncServer( sid = s.manager.connect('123', '/')
client_manager=mgr, async_handlers=False
)
handler = mock.MagicMock(return_value=[1, '2', True]) handler = mock.MagicMock(return_value=[1, '2', True])
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '21000["my message","a","b","c"]')) _run(s._handle_eio_message('123', '21000["my message","a","b","c"]'))
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with(sid, 'a', 'b', 'c')
s.eio.send.mock.assert_called_once_with( s.eio.send.mock.assert_called_once_with(
'123', '31000[[1,"2",true]]', binary=False '123', '31000[[1,"2",true]]'
) )
def test_handle_event_with_ack_binary(self, eio): def test_handle_event_with_ack_binary(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
mgr = self._get_mock_manager() s = asyncio_server.AsyncServer(async_handlers=False)
s = asyncio_server.AsyncServer( sid = s.manager.connect('123', '/')
client_manager=mgr, async_handlers=False
)
handler = mock.MagicMock(return_value=b'foo') handler = mock.MagicMock(return_value=b'foo')
s.on('my message', handler) s.on('my message', handler)
_run(s._handle_eio_message('123', '21000["my message","foo"]')) _run(s._handle_eio_message('123', '21000["my message","foo"]'))
handler.assert_any_call('123', 'foo') handler.assert_any_call(sid, 'foo')
def test_handle_error_packet(self, eio): def test_handle_error_packet(self, eio):
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
@ -712,9 +708,10 @@ class TestAsyncServer(unittest.TestCase):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0'))
cb = mock.MagicMock() cb = mock.MagicMock()
id1 = s.manager._generate_ack_id('123', '/', cb) id1 = s.manager._generate_ack_id('1', cb)
id2 = s.manager._generate_ack_id('123', '/', cb) id2 = s.manager._generate_ack_id('1', cb)
_run(s._emit_internal('123', 'my event', ['foo'], id=id1)) _run(s._emit_internal('123', 'my event', ['foo'], id=id1))
_run(s._emit_internal('123', 'my event', ['bar'], id=id2)) _run(s._emit_internal('123', 'my event', ['bar'], id=id2))
_run(s._handle_eio_message('123', '31["foo",2]')) _run(s._handle_eio_message('123', '31["foo",2]'))
@ -726,7 +723,7 @@ class TestAsyncServer(unittest.TestCase):
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
cb = mock.MagicMock() cb = mock.MagicMock()
id = s.manager._generate_ack_id('123', '/foo', cb) id = s.manager._generate_ack_id('1', cb)
_run( _run(
s._emit_internal( s._emit_internal(
'123', 'my event', ['foo'], namespace='/foo', id=id '123', 'my event', ['foo'], namespace='/foo', id=id
@ -775,18 +772,20 @@ class TestAsyncServer(unittest.TestCase):
eio.return_value.disconnect = AsyncMock() eio.return_value.disconnect = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s.disconnect('123')) _run(s._handle_eio_message('123', '0'))
s.eio.send.mock.assert_any_call('123', '1', binary=False) _run(s.disconnect('1'))
s.eio.disconnect.mock.assert_called_once_with('123') s.eio.send.mock.assert_any_call('123', '1')
assert not s.manager.is_connected('1', '/')
def test_disconnect_ignore_queue(self, eio): def test_disconnect_ignore_queue(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
eio.return_value.disconnect = AsyncMock() eio.return_value.disconnect = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s.disconnect('123', ignore_queue=True)) _run(s._handle_eio_message('123', '0'))
s.eio.send.mock.assert_any_call('123', '1', binary=False) _run(s.disconnect('1', ignore_queue=True))
s.eio.disconnect.mock.assert_called_once_with('123') s.eio.send.mock.assert_any_call('123', '1')
assert not s.manager.is_connected('1', '/')
def test_disconnect_namespace(self, eio): def test_disconnect_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
@ -794,29 +793,31 @@ class TestAsyncServer(unittest.TestCase):
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
_run(s.disconnect('123', namespace='/foo')) _run(s.disconnect('1', namespace='/foo'))
s.eio.send.mock.assert_any_call('123', '1/foo', binary=False) s.eio.send.mock.assert_any_call('123', '1/foo')
s.eio.disconnect.mock.assert_not_called() assert not s.manager.is_connected('1', '/foo')
def test_disconnect_twice(self, eio): def test_disconnect_twice(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
eio.return_value.disconnect = AsyncMock() eio.return_value.disconnect = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s.disconnect('123')) _run(s._handle_eio_message('123', '0'))
_run(s.disconnect('1'))
calls = s.eio.send.mock.call_count calls = s.eio.send.mock.call_count
_run(s.disconnect('123')) assert not s.manager.is_connected('1', '/')
_run(s.disconnect('1'))
assert calls == s.eio.send.mock.call_count assert calls == s.eio.send.mock.call_count
assert s.eio.disconnect.mock.call_count == 1
def test_disconnect_twice_namespace(self, eio): def test_disconnect_twice_namespace(self, eio):
eio.return_value.send = AsyncMock() eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer() s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
_run(s.disconnect('123', namespace='/foo')) _run(s.disconnect('1', namespace='/foo'))
calls = s.eio.send.mock.call_count calls = s.eio.send.mock.call_count
_run(s.disconnect('123', namespace='/foo')) assert not s.manager.is_connected('1', '/foo')
_run(s.disconnect('1', namespace='/foo'))
assert calls == s.eio.send.mock.call_count assert calls == s.eio.send.mock.call_count
def test_namespace_handler(self, eio): def test_namespace_handler(self, eio):
@ -843,15 +844,15 @@ class TestAsyncServer(unittest.TestCase):
s.register_namespace(MyNamespace('/foo')) s.register_namespace(MyNamespace('/foo'))
_run(s._handle_eio_connect('123', 'environ')) _run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo')) _run(s._handle_eio_message('123', '0/foo'))
assert result['result'] == ('123', 'environ') assert result['result'] == ('1', 'environ')
_run(s._handle_eio_message('123', '2/foo,["foo","a"]')) _run(s._handle_eio_message('123', '2/foo,["foo","a"]'))
assert result['result'] == ('123', 'a') assert result['result'] == ('1', 'a')
_run(s._handle_eio_message('123', '2/foo,["bar"]')) _run(s._handle_eio_message('123', '2/foo,["bar"]'))
assert result['result'] == 'bar' assert result['result'] == 'bar'
_run(s._handle_eio_message('123', '2/foo,["baz","a","b"]')) _run(s._handle_eio_message('123', '2/foo,["baz","a","b"]'))
assert result['result'] == ('a', 'b') assert result['result'] == ('a', 'b')
_run(s.disconnect('123', '/foo')) _run(s.disconnect('1', '/foo'))
assert result['result'] == ('disconnect', '123') assert result['result'] == ('disconnect', '1')
def test_bad_namespace_handler(self, eio): def test_bad_namespace_handler(self, eio):
class Dummy(object): class Dummy(object):
@ -927,6 +928,7 @@ class TestAsyncServer(unittest.TestCase):
s.eio.start_background_task.assert_called_once_with( s.eio.start_background_task.assert_called_once_with(
s._handle_event_internal, s._handle_event_internal,
s, s,
'1',
'123', '123',
['my message', 'a', 'b', 'c'], ['my message', 'a', 'b', 'c'],
'/', '/',

293
tests/common/test_server.py
View File

@ -16,7 +16,8 @@ from socketio import server
import pytest import pytest
@mock.patch('engineio.Server') @mock.patch('socketio.server.engineio.Server', **{
'return_value.generate_id.side_effect': [str(i) for i in range(1, 10)]})
class TestServer(unittest.TestCase): class TestServer(unittest.TestCase):
def tearDown(self): def tearDown(self):
# restore JSON encoder, in case a test changed it # restore JSON encoder, in case a test changed it
@ -25,14 +26,13 @@ class TestServer(unittest.TestCase):
def test_create(self, eio): def test_create(self, eio):
mgr = mock.MagicMock() mgr = mock.MagicMock()
s = server.Server( s = server.Server(
client_manager=mgr, binary=True, async_handlers=True, foo='bar' client_manager=mgr, async_handlers=True, foo='bar'
) )
s.handle_request({}, None) s.handle_request({}, None)
s.handle_request({}, None) s.handle_request({}, None)
eio.assert_called_once_with(**{'foo': 'bar', 'async_handlers': False}) eio.assert_called_once_with(**{'foo': 'bar', 'async_handlers': False})
assert s.manager == mgr assert s.manager == mgr
assert s.eio.on.call_count == 3 assert s.eio.on.call_count == 3
assert s.binary
assert s.async_handlers assert s.async_handlers
def test_on_event(self, eio): def test_on_event(self, eio):
@ -266,47 +266,47 @@ class TestServer(unittest.TestCase):
s = server.Server() s = server.Server()
s._emit_internal('123', 'my event', 'my data', namespace='/foo') s._emit_internal('123', 'my event', 'my data', namespace='/foo')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2/foo,["my event","my data"]', binary=False '123', '2/foo,["my event","my data"]'
) )
def test_emit_internal_with_tuple(self, eio): def test_emit_internal_with_tuple(self, eio):
s = server.Server() s = server.Server()
s._emit_internal('123', 'my event', ('foo', 'bar'), namespace='/foo') s._emit_internal('123', 'my event', ('foo', 'bar'), namespace='/foo')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2/foo,["my event","foo","bar"]', binary=False '123', '2/foo,["my event","foo","bar"]'
) )
def test_emit_internal_with_list(self, eio): def test_emit_internal_with_list(self, eio):
s = server.Server() s = server.Server()
s._emit_internal('123', 'my event', ['foo', 'bar'], namespace='/foo') s._emit_internal('123', 'my event', ['foo', 'bar'], namespace='/foo')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2/foo,["my event",["foo","bar"]]', binary=False '123', '2/foo,["my event",["foo","bar"]]'
) )
def test_emit_internal_with_none(self, eio): def test_emit_internal_with_none(self, eio):
s = server.Server() s = server.Server()
s._emit_internal('123', 'my event', None, namespace='/foo') s._emit_internal('123', 'my event', None, namespace='/foo')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2/foo,["my event"]', binary=False '123', '2/foo,["my event"]'
) )
def test_emit_internal_with_callback(self, eio): def test_emit_internal_with_callback(self, eio):
s = server.Server() s = server.Server()
id = s.manager._generate_ack_id('123', '/foo', 'cb') id = s.manager._generate_ack_id('1', 'cb')
s._emit_internal('123', 'my event', 'my data', namespace='/foo', id=id) s._emit_internal('123', 'my event', 'my data', namespace='/foo', id=id)
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2/foo,1["my event","my data"]', binary=False '123', '2/foo,1["my event","my data"]'
) )
def test_emit_internal_default_namespace(self, eio): def test_emit_internal_default_namespace(self, eio):
s = server.Server() s = server.Server()
s._emit_internal('123', 'my event', 'my data') s._emit_internal('123', 'my event', 'my data')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_once_with(
'123', '2["my event","my data"]', binary=False '123', '2["my event","my data"]'
) )
def test_emit_internal_binary(self, eio): def test_emit_internal_binary(self, eio):
s = server.Server(binary=True) s = server.Server()
s._emit_internal('123', u'my event', b'my binary data') s._emit_internal('123', u'my event', b'my binary data')
assert s.eio.send.call_count == 2 assert s.eio.send.call_count == 2
@ -318,158 +318,157 @@ class TestServer(unittest.TestCase):
s.eio.transport.assert_called_once_with('foo') s.eio.transport.assert_called_once_with('foo')
def test_handle_connect(self, eio): def test_handle_connect(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr) s.manager.initialize = mock.MagicMock()
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('connect', handler) s.on('connect', handler)
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
handler.assert_called_once_with('123', 'environ') s._handle_eio_message('123', '0')
s.manager.connect.assert_called_once_with('123', '/') assert s.manager.is_connected('1', '/')
s.eio.send.assert_called_once_with('123', '0', binary=False) handler.assert_called_once_with('1', 'environ')
assert mgr.initialize.call_count == 1 s.eio.send.assert_called_once_with('123', '0{"sid":"1"}')
assert s.manager.initialize.call_count == 1
s._handle_eio_connect('456', 'environ') s._handle_eio_connect('456', 'environ')
assert mgr.initialize.call_count == 1 assert s.manager.initialize.call_count == 1
def test_handle_connect_namespace(self, eio): def test_handle_connect_namespace(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
handler.assert_called_once_with('123', 'environ') assert s.manager.is_connected('1', '/foo')
s.manager.connect.assert_any_call('123', '/') handler.assert_called_once_with('1', 'environ')
s.manager.connect.assert_any_call('123', '/foo') s.eio.send.assert_called_once_with('123', '0/foo,{"sid":"1"}')
s.eio.send.assert_any_call('123', '0/foo', binary=False)
def test_handle_connect_always_connect(self, eio):
s = server.Server(always_connect=True)
s.manager.initialize = mock.MagicMock()
handler = mock.MagicMock()
s.on('connect', handler)
s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0')
assert s.manager.is_connected('1', '/')
handler.assert_called_once_with('1', 'environ')
s.eio.send.assert_called_once_with('123', '0{"sid":"1"}')
assert s.manager.initialize.call_count == 1
s._handle_eio_connect('456', 'environ')
assert s.manager.initialize.call_count == 1
def test_handle_connect_rejected(self, eio): def test_handle_connect_rejected(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler) s.on('connect', handler)
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
assert not ret s._handle_eio_message('123', '0')
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 assert not s.manager.is_connected('1', '/')
assert s.environ == {} s.eio.send.assert_called_once_with('123', '4')
assert s.environ == {'123': 'environ'}
def test_handle_connect_namespace_rejected(self, eio): def test_handle_connect_namespace_rejected(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 assert not s.manager.is_connected('1', '/foo')
s.eio.send.assert_called_once_with('123', '4/foo')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.assert_any_call('123', '4/foo', binary=False)
def test_handle_connect_rejected_always_connect(self, eio): def test_handle_connect_rejected_always_connect(self, eio):
mgr = mock.MagicMock() s = server.Server(always_connect=True)
s = server.Server(client_manager=mgr, always_connect=True)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler) s.on('connect', handler)
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
assert not ret s._handle_eio_message('123', '0')
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.assert_any_call('123', '0{"sid":"1"}')
assert s.environ == {} s.eio.send.assert_any_call('123', '1')
s.eio.send.assert_any_call('123', '0', binary=False) assert s.environ == {'123': 'environ'}
s.eio.send.assert_any_call('123', '1', binary=False)
def test_handle_connect_namespace_rejected_always_connect(self, eio): def test_handle_connect_namespace_rejected_always_connect(self, eio):
mgr = mock.MagicMock() s = server.Server(always_connect=True)
s = server.Server(client_manager=mgr, always_connect=True)
handler = mock.MagicMock(return_value=False) handler = mock.MagicMock(return_value=False)
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.assert_any_call('123', '0/foo,{"sid":"1"}')
s.eio.send.assert_any_call('123', '1/foo')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.assert_any_call('123', '0/foo', binary=False)
s.eio.send.assert_any_call('123', '1/foo', binary=False)
def test_handle_connect_rejected_with_exception(self, eio): def test_handle_connect_rejected_with_exception(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError('fail_reason') side_effect=exceptions.ConnectionRefusedError('fail_reason')
) )
s.on('connect', handler) s.on('connect', handler)
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
assert ret == 'fail_reason' s._handle_eio_message('123', '0')
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.assert_called_once_with('123', '4"fail_reason"')
assert s.environ == {} assert s.environ == {'123': 'environ'}
def test_handle_connect_rejected_with_empty_exception(self, eio): def test_handle_connect_rejected_with_empty_exception(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError() side_effect=exceptions.ConnectionRefusedError()
) )
s.on('connect', handler) s.on('connect', handler)
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
assert not ret s._handle_eio_message('123', '0')
handler.assert_called_once_with('123', 'environ') assert not s.manager.is_connected('1', '/')
assert s.manager.connect.call_count == 1 handler.assert_called_once_with('1', 'environ')
assert s.manager.disconnect.call_count == 1 s.eio.send.assert_called_once_with('123', '4')
assert s.environ == {} assert s.environ == {'123': 'environ'}
def test_handle_connect_namespace_rejected_with_exception(self, eio): def test_handle_connect_namespace_rejected_with_exception(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError(u'fail_reason', 1) side_effect=exceptions.ConnectionRefusedError(u'fail_reason', 1)
) )
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 s.eio.send.assert_called_once_with(
assert s.manager.disconnect.call_count == 1 '123', '4/foo,["fail_reason",1]'
assert s.environ == {'123': 'environ'}
s.eio.send.assert_any_call(
'123', '4/foo,["fail_reason",1]', binary=False
) )
assert s.environ == {'123': 'environ'}
def test_handle_connect_namespace_rejected_with_empty_exception(self, eio): def test_handle_connect_namespace_rejected_with_empty_exception(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
handler = mock.MagicMock( handler = mock.MagicMock(
side_effect=exceptions.ConnectionRefusedError() side_effect=exceptions.ConnectionRefusedError()
) )
s.on('connect', handler, namespace='/foo') s.on('connect', handler, namespace='/foo')
ret = s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
assert ret is None assert not s.manager.is_connected('1', '/foo')
assert s.manager.connect.call_count == 2 s.eio.send.assert_called_once_with('123', '4/foo')
assert s.manager.disconnect.call_count == 1
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
s.eio.send.assert_any_call('123', '4/foo', binary=False)
def test_handle_disconnect(self, eio): def test_handle_disconnect(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr) s.manager.disconnect = mock.MagicMock()
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0')
s._handle_eio_disconnect('123') s._handle_eio_disconnect('123')
handler.assert_called_once_with('123') handler.assert_called_once_with('1')
s.manager.disconnect.assert_called_once_with('123', '/') s.manager.disconnect.assert_called_once_with('1', '/')
assert s.environ == {} assert s.environ == {}
def test_handle_disconnect_namespace(self, eio): def test_handle_disconnect_namespace(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
s.manager.get_namespaces = mock.MagicMock(return_value=['/', '/foo'])
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
handler_namespace = mock.MagicMock() handler_namespace = mock.MagicMock()
@ -477,14 +476,12 @@ class TestServer(unittest.TestCase):
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
s._handle_eio_disconnect('123') s._handle_eio_disconnect('123')
handler.assert_called_once_with('123') handler.assert_not_called()
handler_namespace.assert_called_once_with('123') handler_namespace.assert_called_once_with('1')
assert s.environ == {} assert s.environ == {}
def test_handle_disconnect_only_namespace(self, eio): def test_handle_disconnect_only_namespace(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr)
s.manager.get_namespaces = mock.MagicMock(return_value=['/', '/foo'])
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('disconnect', handler) s.on('disconnect', handler)
handler_namespace = mock.MagicMock() handler_namespace = mock.MagicMock()
@ -493,7 +490,7 @@ class TestServer(unittest.TestCase):
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
s._handle_eio_message('123', '1/foo') s._handle_eio_message('123', '1/foo')
assert handler.call_count == 0 assert handler.call_count == 0
handler_namespace.assert_called_once_with('123') handler_namespace.assert_called_once_with('1')
assert s.environ == {'123': 'environ'} assert s.environ == {'123': 'environ'}
def test_handle_disconnect_unknown_client(self, eio): def test_handle_disconnect_unknown_client(self, eio):
@ -507,7 +504,7 @@ class TestServer(unittest.TestCase):
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('my message', handler) s.on('my message', handler)
s._handle_eio_message('123', '2["my message","a","b","c"]') s._handle_eio_message('123', '2["my message","a","b","c"]')
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with('1', 'a', 'b', 'c')
def test_handle_event_with_namespace(self, eio): def test_handle_event_with_namespace(self, eio):
s = server.Server(async_handlers=False) s = server.Server(async_handlers=False)
@ -515,7 +512,7 @@ class TestServer(unittest.TestCase):
handler = mock.MagicMock() handler = mock.MagicMock()
s.on('my message', handler, namespace='/foo') s.on('my message', handler, namespace='/foo')
s._handle_eio_message('123', '2/foo,["my message","a","b","c"]') s._handle_eio_message('123', '2/foo,["my message","a","b","c"]')
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with('1', 'a', 'b', 'c')
def test_handle_event_with_disconnected_namespace(self, eio): def test_handle_event_with_disconnected_namespace(self, eio):
s = server.Server(async_handlers=False) s = server.Server(async_handlers=False)
@ -538,68 +535,67 @@ class TestServer(unittest.TestCase):
) )
s._handle_eio_message('123', b'foo') s._handle_eio_message('123', b'foo')
s._handle_eio_message('123', b'bar') s._handle_eio_message('123', b'bar')
handler.assert_called_once_with('123', 'a', b'bar', b'foo') handler.assert_called_once_with('1', 'a', b'bar', b'foo')
def test_handle_event_binary_ack(self, eio): def test_handle_event_binary_ack(self, eio):
mgr = mock.MagicMock() s = server.Server()
s = server.Server(client_manager=mgr) s.manager.trigger_callback = mock.MagicMock()
sid = s.manager.connect('123', '/')
s._handle_eio_message( s._handle_eio_message(
'123', '61-321["my message","a",' '{"_placeholder":true,"num":0}]' '123', '61-321["my message","a",' '{"_placeholder":true,"num":0}]'
) )
s._handle_eio_message('123', b'foo') s._handle_eio_message('123', b'foo')
mgr.trigger_callback.assert_called_once_with( s.manager.trigger_callback.assert_called_once_with(
'123', '/', 321, ['my message', 'a', b'foo'] sid, 321, ['my message', 'a', b'foo']
) )
def test_handle_event_with_ack(self, eio): def test_handle_event_with_ack(self, eio):
s = server.Server(async_handlers=False) s = server.Server(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = mock.MagicMock(return_value='foo') handler = mock.MagicMock(return_value='foo')
s.on('my message', handler) s.on('my message', handler)
s._handle_eio_message('123', '21000["my message","foo"]') s._handle_eio_message('123', '21000["my message","foo"]')
handler.assert_called_once_with('123', 'foo') handler.assert_called_once_with(sid, 'foo')
s.eio.send.assert_called_once_with('123', '31000["foo"]', binary=False) s.eio.send.assert_called_once_with('123', '31000["foo"]')
def test_handle_event_with_ack_none(self, eio): def test_handle_event_with_ack_none(self, eio):
s = server.Server(async_handlers=False) s = server.Server(async_handlers=False)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
handler = mock.MagicMock(return_value=None) handler = mock.MagicMock(return_value=None)
s.on('my message', handler) s.on('my message', handler)
s._handle_eio_message('123', '21000["my message","foo"]') s._handle_eio_message('123', '21000["my message","foo"]')
handler.assert_called_once_with('123', 'foo') handler.assert_called_once_with(sid, 'foo')
s.eio.send.assert_called_once_with('123', '31000[]', binary=False) s.eio.send.assert_called_once_with('123', '31000[]')
def test_handle_event_with_ack_tuple(self, eio): def test_handle_event_with_ack_tuple(self, eio):
mgr = mock.MagicMock() s = server.Server(async_handlers=False)
s = server.Server(client_manager=mgr, async_handlers=False)
handler = mock.MagicMock(return_value=(1, '2', True)) handler = mock.MagicMock(return_value=(1, '2', True))
s.on('my message', handler) s.on('my message', handler)
sid = s.manager.connect('123', '/')
s._handle_eio_message('123', '21000["my message","a","b","c"]') s._handle_eio_message('123', '21000["my message","a","b","c"]')
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with(sid, 'a', 'b', 'c')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_with(
'123', '31000[1,"2",true]', binary=False '123', '31000[1,"2",true]'
) )
def test_handle_event_with_ack_list(self, eio): def test_handle_event_with_ack_list(self, eio):
mgr = mock.MagicMock() s = server.Server(async_handlers=False)
s = server.Server(client_manager=mgr, async_handlers=False)
handler = mock.MagicMock(return_value=[1, '2', True]) handler = mock.MagicMock(return_value=[1, '2', True])
s.on('my message', handler) s.on('my message', handler)
sid = s.manager.connect('123', '/')
s._handle_eio_message('123', '21000["my message","a","b","c"]') s._handle_eio_message('123', '21000["my message","a","b","c"]')
handler.assert_called_once_with('123', 'a', 'b', 'c') handler.assert_called_once_with(sid, 'a', 'b', 'c')
s.eio.send.assert_called_once_with( s.eio.send.assert_called_with(
'123', '31000[[1,"2",true]]', binary=False '123', '31000[[1,"2",true]]'
) )
def test_handle_event_with_ack_binary(self, eio): def test_handle_event_with_ack_binary(self, eio):
mgr = mock.MagicMock() s = server.Server(async_handlers=False)
s = server.Server(
client_manager=mgr, binary=True, async_handlers=False
)
handler = mock.MagicMock(return_value=b'foo') handler = mock.MagicMock(return_value=b'foo')
s.on('my message', handler) s.on('my message', handler)
sid = s.manager.connect('123', '/')
s._handle_eio_message('123', '21000["my message","foo"]') s._handle_eio_message('123', '21000["my message","foo"]')
handler.assert_any_call('123', 'foo') handler.assert_any_call(sid, 'foo')
def test_handle_error_packet(self, eio): def test_handle_error_packet(self, eio):
s = server.Server() s = server.Server()
@ -614,9 +610,10 @@ class TestServer(unittest.TestCase):
def test_send_with_ack(self, eio): def test_send_with_ack(self, eio):
s = server.Server() s = server.Server()
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0')
cb = mock.MagicMock() cb = mock.MagicMock()
id1 = s.manager._generate_ack_id('123', '/', cb) id1 = s.manager._generate_ack_id('1', cb)
id2 = s.manager._generate_ack_id('123', '/', cb) id2 = s.manager._generate_ack_id('1', cb)
s._emit_internal('123', 'my event', ['foo'], id=id1) s._emit_internal('123', 'my event', ['foo'], id=id1)
s._emit_internal('123', 'my event', ['bar'], id=id2) s._emit_internal('123', 'my event', ['bar'], id=id2)
s._handle_eio_message('123', '31["foo",2]') s._handle_eio_message('123', '31["foo",2]')
@ -627,7 +624,7 @@ class TestServer(unittest.TestCase):
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
cb = mock.MagicMock() cb = mock.MagicMock()
id = s.manager._generate_ack_id('123', '/foo', cb) id = s.manager._generate_ack_id('1', cb)
s._emit_internal('123', 'my event', ['foo'], namespace='/foo', id=id) s._emit_internal('123', 'my event', ['foo'], namespace='/foo', id=id)
s._handle_eio_message('123', '3/foo,1["foo",2]') s._handle_eio_message('123', '3/foo,1["foo",2]')
cb.assert_called_once_with('foo', 2) cb.assert_called_once_with('foo', 2)
@ -665,28 +662,31 @@ class TestServer(unittest.TestCase):
def test_disconnect(self, eio): def test_disconnect(self, eio):
s = server.Server() s = server.Server()
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s.disconnect('123') s._handle_eio_message('123', '0')
s.eio.send.assert_any_call('123', '1', binary=False) s.disconnect('1')
s.eio.send.assert_any_call('123', '1')
def test_disconnect_ignore_queue(self, eio): def test_disconnect_ignore_queue(self, eio):
s = server.Server() s = server.Server()
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s.disconnect('123', ignore_queue=True) s._handle_eio_message('123', '0')
s.eio.send.assert_any_call('123', '1', binary=False) s.disconnect('1', ignore_queue=True)
s.eio.send.assert_any_call('123', '1')
def test_disconnect_namespace(self, eio): def test_disconnect_namespace(self, eio):
s = server.Server() s = server.Server()
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
s.disconnect('123', namespace='/foo') s.disconnect('1', namespace='/foo')
s.eio.send.assert_any_call('123', '1/foo', binary=False) s.eio.send.assert_any_call('123', '1/foo')
def test_disconnect_twice(self, eio): def test_disconnect_twice(self, eio):
s = server.Server() s = server.Server()
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s.disconnect('123') s._handle_eio_message('123', '0')
s.disconnect('1')
calls = s.eio.send.call_count calls = s.eio.send.call_count
s.disconnect('123') s.disconnect('1')
assert calls == s.eio.send.call_count assert calls == s.eio.send.call_count
def test_disconnect_twice_namespace(self, eio): def test_disconnect_twice_namespace(self, eio):
@ -721,15 +721,15 @@ class TestServer(unittest.TestCase):
s.register_namespace(MyNamespace('/foo')) s.register_namespace(MyNamespace('/foo'))
s._handle_eio_connect('123', 'environ') s._handle_eio_connect('123', 'environ')
s._handle_eio_message('123', '0/foo') s._handle_eio_message('123', '0/foo')
assert result['result'] == ('123', 'environ') assert result['result'] == ('1', 'environ')
s._handle_eio_message('123', '2/foo,["foo","a"]') s._handle_eio_message('123', '2/foo,["foo","a"]')
assert result['result'] == ('123', 'a') assert result['result'] == ('1', 'a')
s._handle_eio_message('123', '2/foo,["bar"]') s._handle_eio_message('123', '2/foo,["bar"]')
assert result['result'] == 'bar' assert result['result'] == 'bar'
s._handle_eio_message('123', '2/foo,["baz","a","b"]') s._handle_eio_message('123', '2/foo,["baz","a","b"]')
assert result['result'] == ('a', 'b') assert result['result'] == ('a', 'b')
s.disconnect('123', '/foo') s.disconnect('1', '/foo')
assert result['result'] == ('disconnect', '123') assert result['result'] == ('disconnect', '1')
def test_bad_namespace_handler(self, eio): def test_bad_namespace_handler(self, eio):
class Dummy(object): class Dummy(object):
@ -801,11 +801,12 @@ class TestServer(unittest.TestCase):
def test_async_handlers(self, eio): def test_async_handlers(self, eio):
s = server.Server(async_handlers=True) s = server.Server(async_handlers=True)
s.manager.connect('123', '/') sid = s.manager.connect('123', '/')
s._handle_eio_message('123', '2["my message","a","b","c"]') s._handle_eio_message('123', '2["my message","a","b","c"]')
s.eio.start_background_task.assert_called_once_with( s.eio.start_background_task.assert_called_once_with(
s._handle_event_internal, s._handle_event_internal,
s, s,
sid,
'123', '123',
['my message', 'a', 'b', 'c'], ['my message', 'a', 'b', 'c'],
'/', '/',

Write Preview
Loading…
Cancel
Save