def test_call(self):
c = client.Client()
def fake_event_wait(timeout=None):
self.assertEqual(timeout, 60)
c._generate_ack_id.call_args_list[0][0][1]('foo', 321)
return True
c._send_packet = mock.MagicMock()
c._generate_ack_id = mock.MagicMock(return_value=123)
c.eio = mock.MagicMock()
c.eio.create_event.return_value.wait = fake_event_wait
self.assertEqual(c.call('foo'), ('foo', 321))
expected_packet = packet.Packet(packet.EVENT,
namespace='/',
data=['foo'],
id=123,
binary=False)
self.assertEqual(c._send_packet.call_count, 1)
self.assertEqual(c._send_packet.call_args_list[0][0][0].encode(),
expected_packet.encode())
def test_call(self):
c = client.Client()
c.namespaces = {'/': '1'}
def fake_event_wait(timeout=None):
assert timeout == 60
c._generate_ack_id.call_args_list[0][0][1]('foo', 321)
return True
c._send_packet = mock.MagicMock()
c._generate_ack_id = mock.MagicMock(return_value=123)
c.eio = mock.MagicMock()
c.eio.create_event.return_value.wait = fake_event_wait
assert c.call('foo') == ('foo', 321)
expected_packet = packet.Packet(packet.EVENT,
namespace='/',
data=['foo'],
id=123)
assert c._send_packet.call_count == 1
assert (c._send_packet.call_args_list[0][0][0].encode() ==
expected_packet.encode())
def test_connect_no_namespaces(self):
c = client.Client()
c.eio.connect = mock.MagicMock()
c.connect(
'url',
headers='headers',
transports='transports',
socketio_path='path',
wait=False,
)
assert c.connection_url == 'url'
assert c.connection_headers == 'headers'
assert c.connection_transports == 'transports'
assert c.connection_namespaces == ['/']
assert c.socketio_path == 'path'
c.eio.connect.assert_called_once_with(
'url',
headers='headers',
transports='transports',
engineio_path='path',
)
def test_call_with_timeout(self):
c = client.Client()
c.namespaces = {'/': '1'}
def fake_event_wait(timeout=None):
assert timeout == 12
return False
c._send_packet = mock.MagicMock()
c._generate_ack_id = mock.MagicMock(return_value=123)
c.eio = mock.MagicMock()
c.eio.create_event.return_value.wait = fake_event_wait
with pytest.raises(exceptions.TimeoutError):
c.call('foo', timeout=12)
expected_packet = packet.Packet(packet.EVENT,
namespace='/',
data=['foo'],
id=123)
assert c._send_packet.call_count == 1
assert (c._send_packet.call_args_list[0][0][0].encode() ==
expected_packet.encode())
def test_disconnect_namespaces(self):
c = client.Client()
c.namespaces = ['/foo', '/bar']
c._trigger_event = mock.MagicMock()
c._send_packet = mock.MagicMock()
c.disconnect()
self.assertEqual(c._trigger_event.call_args_list, [
mock.call('disconnect', namespace='/foo'),
mock.call('disconnect', namespace='/bar'),
mock.call('disconnect', namespace='/')
])
self.assertEqual(c._send_packet.call_count, 3)
expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo')
self.assertEqual(c._send_packet.call_args_list[0][0][0].encode(),
expected_packet.encode())
expected_packet = packet.Packet(packet.DISCONNECT, namespace='/bar')
self.assertEqual(c._send_packet.call_args_list[1][0][0].encode(),
expected_packet.encode())
expected_packet = packet.Packet(packet.DISCONNECT, namespace='/')
self.assertEqual(c._send_packet.call_args_list[2][0][0].encode(),
expected_packet.encode())
def test_connect(self):
c = client.Client()
c.eio.connect = mock.MagicMock()
c.connect(
'url',
headers='headers',
transports='transports',
namespaces=['/foo', '/', '/bar'],
socketio_path='path',
)
assert c.connection_url == 'url'
assert c.connection_headers == 'headers'
assert c.connection_transports == 'transports'
assert c.connection_namespaces == ['/foo', '/', '/bar']
assert c.socketio_path == 'path'
assert c.namespaces == ['/foo', '/bar']
c.eio.connect.assert_called_once_with(
'url',
headers='headers',
transports='transports',
engineio_path='path',
)
def test_handle_eio_connect(self):
c = client.Client()
c.connection_namespaces = ['/', '/foo']
c.connection_auth = 'auth'
c._send_packet = mock.MagicMock()
c.eio.sid = 'foo'
assert c.sid is None
c._handle_eio_connect()
assert c.sid == 'foo'
assert c._send_packet.call_count == 2
expected_packet = packet.Packet(
packet.CONNECT, data='auth', namespace='/')
assert (
c._send_packet.call_args_list[0][0][0].encode()
== expected_packet.encode()
)
expected_packet = packet.Packet(
packet.CONNECT, data='auth', namespace='/foo')
assert (
c._send_packet.call_args_list[1][0][0].encode()
== expected_packet.encode()
)
def test_handle_eio_message(self):
c = client.Client()
c._handle_connect = mock.MagicMock()
c._handle_disconnect = mock.MagicMock()
c._handle_event = mock.MagicMock()
c._handle_ack = mock.MagicMock()
c._handle_error = mock.MagicMock()
c._handle_eio_message('0')
c._handle_connect.assert_called_with(None)
c._handle_eio_message('0/foo')
c._handle_connect.assert_called_with('/foo')
c._handle_eio_message('1')
c._handle_disconnect.assert_called_with(None)
c._handle_eio_message('1/foo')
c._handle_disconnect.assert_called_with('/foo')
c._handle_eio_message('2["foo"]')
c._handle_event.assert_called_with(None, None, ['foo'])
c._handle_eio_message('3/foo,["bar"]')
c._handle_ack.assert_called_with('/foo', None, ['bar'])
c._handle_eio_message('4')
c._handle_error.assert_called_with(None)
c._handle_eio_message('4/foo')
c._handle_error.assert_called_with('/foo')
c._handle_eio_message('51-{"_placeholder":true,"num":0}')
self.assertEqual(c._binary_packet.packet_type, packet.BINARY_EVENT)
c._handle_eio_message(b'foo')
c._handle_event.assert_called_with(None, None, b'foo')
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)
c._handle_eio_message(b'bar')
c._handle_eio_message(b'foo')
c._handle_ack.assert_called_with('/foo', None, {
'1': b'foo',
'2': b'bar'
})
self.assertRaises(ValueError, c._handle_eio_message, '9')
def test_event(self):
c = client.Client()
@c.event
def connect():
pass
@c.event
def foo():
pass
@c.event
def bar():
pass
@c.event(namespace='/foo')
def disconnect():
pass
assert c.handlers['/']['connect'] == connect
assert c.handlers['/']['foo'] == foo
assert c.handlers['/']['bar'] == bar
assert c.handlers['/foo']['disconnect'] == disconnect
def test_event(self):
c = client.Client()
@c.event
def connect():
pass
@c.event
def foo():
pass
@c.event
def bar():
pass
@c.event(namespace='/foo')
def disconnect():
pass
self.assertEqual(c.handlers['/']['connect'], connect)
self.assertEqual(c.handlers['/']['foo'], foo)
self.assertEqual(c.handlers['/']['bar'], bar)
self.assertEqual(c.handlers['/foo']['disconnect'], disconnect)
def test_connect_default_namespaces(self):
c = client.Client()
c.eio.connect = mock.MagicMock()
c.on('foo', mock.MagicMock(), namespace='/foo')
c.on('bar', mock.MagicMock(), namespace='/')
c.connect(
'url',
headers='headers',
transports='transports',
socketio_path='path',
)
assert c.connection_url == 'url'
assert c.connection_headers == 'headers'
assert c.connection_transports == 'transports'
assert c.connection_namespaces is None
assert c.socketio_path == 'path'
assert c.namespaces == ['/foo']
c.eio.connect.assert_called_once_with(
'url',
headers='headers',
transports='transports',
engineio_path='path',
)
def test_create(self, engineio_client_class):
c = client.Client(reconnection=False, reconnection_attempts=123,
reconnection_delay=5, reconnection_delay_max=10,
randomization_factor=0.2, binary=True, foo='bar')
self.assertEqual(c.reconnection, False)
self.assertEqual(c.reconnection_attempts, 123)
self.assertEqual(c.reconnection_delay, 5)
self.assertEqual(c.reconnection_delay_max, 10)
self.assertEqual(c.randomization_factor, 0.2)
self.assertEqual(c.binary, True)
engineio_client_class().assert_called_once_with(foo='bar')
self.assertEqual(c.connection_url, None)
self.assertEqual(c.connection_headers, None)
self.assertEqual(c.connection_transports, None)
self.assertEqual(c.connection_namespaces, None)
self.assertEqual(c.socketio_path, None)
self.assertEqual(c.namespaces, [])
self.assertEqual(c.handlers, {})
self.assertEqual(c.namespace_handlers, {})
self.assertEqual(c.callbacks, {})
self.assertEqual(c._binary_packet, None)
self.assertEqual(c._reconnect_task, None)
def test_connect_wait_two_namespaces(self):
c = client.Client()
c.eio.connect = mock.MagicMock()
c._connect_event = mock.MagicMock()
def mock_connect(timeout):
assert timeout == 0.01
if c.namespaces == {}:
c.namespaces = {'/bar': '123'}
return True
elif c.namespaces == {'/bar': '123'}:
c.namespaces = {'/bar': '123', '/foo': '456'}
return True
return False
c._connect_event.wait = mock_connect
c.connect(
'url',
namespaces=['/foo', '/bar'],
wait=True,
wait_timeout=0.01,
)
assert c.connected is True
assert c.namespaces == {'/bar': '123', '/foo': '456'}
def test_eio_disconnect_reconnect(self):
c = client.Client(reconnection=True)
c.start_background_task = mock.MagicMock()
c.eio.state = 'connected'
c._handle_eio_disconnect()
c.start_background_task.assert_called_once_with(c._handle_reconnect)
def test_eio_disconnect(self):
c = client.Client()
c._trigger_event = mock.MagicMock()
c._handle_eio_disconnect()
c._trigger_event.assert_called_once_with('disconnect', namespace='/')
def test_trigger_event(self):
c = client.Client()
handler = mock.MagicMock()
c.on('foo', handler)
c._trigger_event('foo', '/', 1, '2')
handler.assert_called_once_with(1, '2')
def test_trigger_event_namespace(self):
c = client.Client()
handler = mock.MagicMock()
c.on('foo', handler, namespace='/bar')
c._trigger_event('foo', '/bar', 1, '2')
handler.assert_called_once_with(1, '2')
def test_emit_unknown_namespace(self):
c = client.Client()
c.namespaces = ['/foo']
with pytest.raises(exceptions.BadNamespaceError):
c.emit('foo', namespace='/bar')
def test_handle_error_unknown_namespace(self):
c = client.Client()
c.namespaces = ['/foo', '/bar']
c._handle_error('/baz')
self.assertEqual(c.namespaces, ['/foo', '/bar'])
def test_sleep(self):
c = client.Client()
c.eio.sleep = mock.MagicMock()
c.sleep(1.23)
c.eio.sleep.assert_called_once_with(1.23)
def test_send_packet_default_binary_py3(self):
c = client.Client()
c.eio.send = mock.MagicMock()
c._send_packet(packet.Packet(packet.EVENT, 'foo'))
c.eio.send.assert_called_once_with('2"foo"', binary=False)
def test_is_asyncio_based(self):
c = client.Client()
self.assertEqual(c.is_asyncio_based(), False)
def test_transport(self):
c = client.Client()
c.eio.transport = mock.MagicMock(return_value='foo')
self.assertEqual(c.transport(), 'foo')
c.eio.transport.assert_called_once_with()
def test_send_with_defaults(self):
c = client.Client()
c.emit = mock.MagicMock()
c.send('data')
c.emit.assert_called_once_with(
'message', data='data', namespace=None, callback=None)
def test_send_packet(self):
c = client.Client()
c.eio.send = mock.MagicMock()
c._send_packet(packet.Packet(packet.EVENT, 'foo'))
c.eio.send.assert_called_once_with('2"foo"')
def test_handle_eio_connect(self):
c = client.Client()
c.eio.sid = 'foo'
assert c.sid is None
c._handle_eio_connect()
assert c.sid == 'foo'
def test_engineio_logger(self, engineio_client_class):
client.Client(engineio_logger='foo')
engineio_client_class().assert_called_once_with(logger='foo')
def test_handle_event(self):
c = client.Client()
c._trigger_event = mock.MagicMock()
c._handle_event('/', None, ['foo', ('bar', 'baz')])
c._trigger_event.assert_called_once_with('foo', '/', ('bar', 'baz'))
def test_eio_disconnect_no_reconnect(self):
c = client.Client(reconnection=False)
c.start_background_task = mock.MagicMock()
c.eio.state = 'connected'
c._handle_eio_disconnect()
c.start_background_task.assert_not_called()
def test_is_asyncio_based(self):
c = client.Client()
assert not c.is_asyncio_based()
