def test_session(self, eio):
fake_session = {}
async def fake_get_session(sid):
return fake_session
async def fake_save_session(sid, session):
global fake_session
fake_session = session
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
s.eio.get_session = fake_get_session
s.eio.save_session = fake_save_session
async def _test():
await s._handle_eio_connect('123', 'environ')
await s.save_session('123', {'foo': 'bar'})
async with s.session('123') as session:
self.assertEqual(session, {'foo': 'bar'})
session['foo'] = 'baz'
session['bar'] = 'foo'
self.assertEqual(await s.get_session('123'), {
'foo': 'baz',
'bar': 'foo'
})
self.assertEqual(fake_session, {'/': {'foo': 'baz', 'bar': 'foo'}})
async with s.session('123', namespace='/ns') as session:
self.assertEqual(session, {})
session['a'] = 'b'
self.assertEqual(await s.get_session('123', namespace='/ns'),
{'a': 'b'})
self.assertEqual(fake_session, {
'/': {
'foo': 'baz',
'bar': 'foo'
},
'/ns': {
'a': 'b'
}
})
_run(_test())
def test_session(self, eio):
fake_session = {}
async def fake_get_session(eio_sid):
assert eio_sid == '123'
return fake_session
async def fake_save_session(eio_sid, session):
global fake_session
assert eio_sid == '123'
fake_session = session
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
s.eio.get_session = fake_get_session
s.eio.save_session = fake_save_session
async def _test():
await s._handle_eio_connect('123', 'environ')
await s._handle_eio_message('123', '0')
await s._handle_eio_message('123', '0/ns')
sid = s.manager.sid_from_eio_sid('123', '/')
sid2 = s.manager.sid_from_eio_sid('123', '/ns')
await s.save_session(sid, {'foo': 'bar'})
async with s.session(sid) as session:
assert session == {'foo': 'bar'}
session['foo'] = 'baz'
session['bar'] = 'foo'
assert await s.get_session(sid) == {'foo': 'baz', 'bar': 'foo'}
assert fake_session == {'/': {'foo': 'baz', 'bar': 'foo'}}
async with s.session(sid2, namespace='/ns') as session:
assert session == {}
session['a'] = 'b'
assert await s.get_session(sid2, namespace='/ns') == {'a': 'b'}
assert fake_session == {
'/': {'foo': 'baz', 'bar': 'foo'},
'/ns': {'a': 'b'},
}
_run(_test())
def test_emit(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
_run(
s.emit(
'my event',
{'foo': 'bar'},
to='room',
skip_sid='123',
namespace='/foo',
callback='cb',
)
)
s.manager.emit.mock.assert_called_once_with(
'my event',
{'foo': 'bar'},
'/foo',
room='room',
skip_sid='123',
callback='cb',
)
_run(
s.emit(
'my event',
{'foo': 'bar'},
room='room',
skip_sid='123',
namespace='/foo',
callback='cb',
)
)
s.manager.emit.mock.assert_called_with(
'my event',
{'foo': 'bar'},
'/foo',
room='room',
skip_sid='123',
callback='cb',
)
def test_namespace_handler(self, eio):
eio.return_value.send = AsyncMock()
result = {}
class MyNamespace(asyncio_namespace.AsyncNamespace):
def on_connect(self, sid, environ):
result['result'] = (sid, environ)
@coroutine
def on_disconnect(self, sid):
result['result'] = ('disconnect', sid)
@coroutine
def on_foo(self, sid, data):
result['result'] = (sid, data)
def on_bar(self, sid):
result['result'] = 'bar'
@coroutine
def on_baz(self, sid, data1, data2):
result['result'] = (data1, data2)
s = asyncio_server.AsyncServer()
s.register_namespace(MyNamespace('/foo'))
_run(s._handle_eio_connect('123', 'environ'))
_run(s._handle_eio_message('123', '0/foo'))
self.assertEqual(result['result'], ('123', 'environ'))
_run(s._handle_eio_message('123', '2/foo,["foo","a"]'))
self.assertEqual(result['result'], ('123', 'a'))
_run(s._handle_eio_message('123', '2/foo,["bar"]'))
self.assertEqual(result['result'], 'bar')
_run(s._handle_eio_message('123', '2/foo,["baz","a","b"]'))
self.assertEqual(result['result'], ('a', 'b'))
_run(s.disconnect('123', '/foo'))
self.assertEqual(result['result'], ('disconnect', '123'))
def test_handle_request(self, eio):
eio.return_value.handle_request = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s.handle_request('environ'))
s.eio.handle_request.mock.assert_called_once_with('environ')
def test_emit_internal_with_none(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', None, namespace='/foo'))
s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event"]', binary=False)
def test_close_room_default_namespace(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
_run(s.close_room('room'))
s.manager.close_room.mock.assert_called_once_with('room', '/')
def test_rooms_default_namespace(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
s.rooms('123')
s.manager.get_rooms.assert_called_once_with('123', '/')
def test_call_with_broadcast(self, eio):
s = asyncio_server.AsyncServer()
with pytest.raises(ValueError):
_run(s.call('foo'))
def test_leave_room_default_namespace(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
s.leave_room('123', 'room')
s.manager.leave_room.assert_called_once_with('123', '/', 'room')
def test_attach(self, eio):
s = asyncio_server.AsyncServer()
s.attach('app', 'path')
eio.return_value.attach.assert_called_once_with('app', 'path')
def test_handle_invalid_packet(self, eio):
s = asyncio_server.AsyncServer()
with pytest.raises(ValueError):
_run(s._handle_eio_message('123', '9'))
def test_disconnect(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s._handle_eio_connect('123', 'environ'))
_run(s.disconnect('123'))
s.eio.send.mock.assert_any_call('123', '1', binary=False)
def test_handle_disconnect_unknown_client(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
_run(s._handle_eio_disconnect('123'))
def test_send(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
_run(s.send('foo', 'room', '123', namespace='/foo', callback='cb'))
s.manager.emit.mock.assert_called_once_with('message', 'foo', '/foo',
'room', '123', 'cb')
def test_emit_default_namespace(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
_run(s.emit('my event', {'foo': 'bar'}, 'room', '123', callback='cb'))
s.manager.emit.mock.assert_called_once_with('my event', {'foo': 'bar'},
'/', 'room', '123', 'cb')
def test_call_with_broadcast(self, eio):
s = asyncio_server.AsyncServer()
self.assertRaises(ValueError, _run, s.call('foo'))
def test_emit_internal_default_namespace(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', 'my data'))
s.eio.send.mock.assert_called_once_with(
'123', '2["my event","my data"]', binary=False)
def test_start_background_task(self, eio):
s = asyncio_server.AsyncServer()
s.start_background_task('foo', 'bar', baz='baz')
s.eio.start_background_task.assert_called_once_with('foo', 'bar',
baz='baz')
def test_emit_internal_binary(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', u'my event', b'my binary data'))
self.assertEqual(s.eio.send.mock.call_count, 2)
def test_emit_internal(self, eio):
eio.return_value.send = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s._emit_internal('123', 'my event', 'my data', namespace='/foo'))
s.eio.send.mock.assert_called_once_with(
'123', '2/foo,["my event","my data"]')
def test_handle_invalid_packet(self, eio):
s = asyncio_server.AsyncServer()
self.assertRaises(ValueError, _run, s._handle_eio_message('123', '9'))
def test_async_handlers(self, eio):
s = asyncio_server.AsyncServer(async_handlers=True)
_run(s._handle_eio_message('123', '2["my message","a","b","c"]'))
s.eio.start_background_task.assert_called_once_with(
s._handle_event_internal, s, '123', ['my message', 'a', 'b', 'c'],
'/', None)
def test_engineio_logger(self, eio):
asyncio_server.AsyncServer(engineio_logger='foo')
eio.assert_called_once_with(**{'logger': 'foo',
'async_handlers': False})
def test_call_without_async_handlers(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr,
async_handlers=False)
self.assertRaises(RuntimeError, _run,
s.call('foo', sid='123', timeout=12))
def test_sleep(self, eio):
eio.return_value.sleep = AsyncMock()
s = asyncio_server.AsyncServer()
_run(s.sleep(1.23))
s.eio.sleep.mock.assert_called_once_with(1.23)
def test_enter_room(self, eio):
mgr = self._get_mock_manager()
s = asyncio_server.AsyncServer(client_manager=mgr)
s.enter_room('123', 'room', namespace='/foo')
s.manager.enter_room.assert_called_once_with('123', '/foo', 'room')
