def test_write_loop_polling_one_packet(self):
c = asyncio_client.AsyncClient()
c.base_url = 'http://foo'
c.state = 'connected'
c.ping_interval = 1
c.ping_timeout = 2
c.current_transport = 'polling'
c.queue = mock.MagicMock()
c.queue.Empty = RuntimeError
c.queue.get = AsyncMock(side_effect=[
packet.Packet(packet.MESSAGE, {'foo': 'bar'}),
RuntimeError
])
c.queue.get_nowait = mock.MagicMock(side_effect=RuntimeError)
c._send_request = AsyncMock()
c._send_request.mock.return_value.status = 200
_run(c._write_loop())
self.assertEqual(c.queue.task_done.call_count, 1)
p = payload.Payload(
packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})])
c._send_request.mock.assert_called_once_with(
'POST', 'http://foo', body=p.encode(),
headers={'Content-Type': 'application/octet-stream'})
def test_polling_connection_successful(self):
c = asyncio_client.AsyncClient()
c._send_request = AsyncMock()
c._send_request.mock.return_value.status = 200
c._send_request.mock.return_value.read = AsyncMock(
return_value=payload.Payload(packets=[
packet.Packet(
packet.OPEN, {
'sid': '123',
'upgrades': [],
'pingInterval': 1000,
'pingTimeout': 2000
})
]).encode())
c._ping_loop = AsyncMock()
c._read_loop_polling = AsyncMock()
c._read_loop_websocket = AsyncMock()
c._write_loop = AsyncMock()
on_connect = AsyncMock()
c.on('connect', on_connect)
_run(c.connect('http://foo'))
time.sleep(0.1)
c._ping_loop.mock.assert_called_once_with()
c._read_loop_polling.mock.assert_called_once_with()
c._read_loop_websocket.mock.assert_not_called()
c._write_loop.mock.assert_called_once_with()
on_connect.mock.assert_called_once_with()
self.assertIn(c, client.connected_clients)
self.assertEqual(
c.base_url,
'http://foo/engine.io/?transport=polling&EIO=3&sid=123')
self.assertEqual(c.sid, '123')
self.assertEqual(c.ping_interval, 1)
self.assertEqual(c.ping_timeout, 2)
self.assertEqual(c.upgrades, [])
self.assertEqual(c.transport(), 'polling')
def test_websocket_connection_successful(self, _time):
c = asyncio_client.AsyncClient()
c.http = mock.MagicMock(closed=False)
c.http.ws_connect = AsyncMock()
ws = c.http.ws_connect.mock.return_value
ws.receive = AsyncMock()
ws.receive.mock.return_value.data = packet.Packet(packet.OPEN, {
'sid': '123', 'upgrades': [], 'pingInterval': 1000,
'pingTimeout': 2000
}).encode()
c._ping_loop = AsyncMock()
c._read_loop_polling = AsyncMock()
c._read_loop_websocket = AsyncMock()
c._write_loop = AsyncMock()
on_connect = mock.MagicMock()
c.on('connect', on_connect)
_run(c.connect('ws://foo', transports=['websocket']))
time.sleep(0.1)
c._ping_loop.mock.assert_called_once_with()
c._read_loop_polling.mock.assert_not_called()
c._read_loop_websocket.mock.assert_called_once_with()
c._write_loop.mock.assert_called_once_with()
on_connect.assert_called_once_with()
self.assertIn(c, client.connected_clients)
self.assertEqual(
c.base_url,
'ws://foo/engine.io/?transport=websocket&EIO=3')
self.assertEqual(c.sid, '123')
self.assertEqual(c.ping_interval, 1)
self.assertEqual(c.ping_timeout, 2)
self.assertEqual(c.upgrades, [])
self.assertEqual(c.transport(), 'websocket')
self.assertEqual(c.ws, ws)
c.http.ws_connect.mock.assert_called_once_with(
'ws://foo/engine.io/?transport=websocket&EIO=3&t=123.456',
headers={})
def test_websocket_https_noverify_connection_successful(self, _time):
ws = asyncio_client.websockets.connect.mock.return_value
ws.recv = AsyncMock(return_value=packet.Packet(
packet.OPEN, {
'sid': '123',
'upgrades': [],
'pingInterval': 1000,
'pingTimeout': 2000
}).encode())
c = asyncio_client.AsyncClient(ssl_verify=False)
c._ping_loop = AsyncMock()
c._read_loop_polling = AsyncMock()
c._read_loop_websocket = AsyncMock()
c._write_loop = AsyncMock()
on_connect = mock.MagicMock()
c.on('connect', on_connect)
_run(c.connect('wss://foo', transports=['websocket']))
time.sleep(0.1)
c._ping_loop.mock.assert_called_once_with()
c._read_loop_polling.mock.assert_not_called()
c._read_loop_websocket.mock.assert_called_once_with()
c._write_loop.mock.assert_called_once_with()
on_connect.assert_called_once_with()
self.assertIn(c, client.connected_clients)
self.assertEqual(c.base_url,
'wss://foo/engine.io/?transport=websocket&EIO=3')
self.assertEqual(c.sid, '123')
self.assertEqual(c.ping_interval, 1)
self.assertEqual(c.ping_timeout, 2)
self.assertEqual(c.upgrades, [])
self.assertEqual(c.transport(), 'websocket')
self.assertEqual(c.ws, ws)
_, kwargs = asyncio_client.websockets.connect.mock.call_args
self.assertTrue('ssl' in kwargs)
self.assertTrue(isinstance(kwargs['ssl'], ssl.SSLContext))
self.assertEqual(kwargs['ssl'].verify_mode, ssl.CERT_NONE)
def test_write_loop_websocket_three_packets(self):
c = asyncio_client.AsyncClient()
c.state = 'connected'
c.ping_interval = 1
c.ping_timeout = 2
c.current_transport = 'websocket'
c.queue = mock.MagicMock()
c.queue.Empty = RuntimeError
c.queue.get = AsyncMock(side_effect=[
packet.Packet(packet.MESSAGE, {'foo': 'bar'}), RuntimeError
])
c.queue.get_nowait = mock.MagicMock(side_effect=[
packet.Packet(packet.PING),
packet.Packet(packet.NOOP), RuntimeError
])
c.ws = mock.MagicMock()
c.ws.send = AsyncMock()
_run(c._write_loop())
self.assertEqual(c.queue.task_done.call_count, 3)
self.assertEqual(c.ws.send.mock.call_count, 3)
self.assertEqual(c.ws.send.mock.call_args_list[0][0][0],
'4{"foo":"bar"}')
self.assertEqual(c.ws.send.mock.call_args_list[1][0][0], '2')
self.assertEqual(c.ws.send.mock.call_args_list[2][0][0], '6')
def test_read_loop_websocket_disconnected(self):
c = asyncio_client.AsyncClient()
c.state = 'disconnected'
c.write_loop_task = AsyncMock()()
c.ping_loop_task = AsyncMock()()
_run(c._read_loop_websocket())
def test_some_invalid_transports(self):
c = asyncio_client.AsyncClient()
c._connect_websocket = AsyncMock()
_run(c.connect('http://foo', transports=['foo', 'websocket', 'bar']))
self.assertEqual(c.transports, ['websocket'])
def test_receive_pong_packet(self):
c = asyncio_client.AsyncClient()
c.pong_received = False
_run(c._receive_packet(packet.Packet(packet.PONG)))
self.assertTrue(c.pong_received)
def test_receive_unknown_packet(self):
c = asyncio_client.AsyncClient()
_run(c._receive_packet(packet.Packet(encoded_packet=b'9')))
def test_already_connected(self):
c = asyncio_client.AsyncClient()
c.state = 'connected'
self.assertRaises(ValueError, _run, c.connect('http://foo'))
def test_connect_query_string(self):
c = asyncio_client.AsyncClient()
c._connect_polling = AsyncMock(return_value='foo')
self.assertEqual(_run(c.connect('http://foo?bar=baz')), 'foo')
c._connect_polling.mock.assert_called_once_with(
'http://foo?bar=baz', {}, 'engine.io')
def test_receive_message_packet(self):
c = asyncio_client.AsyncClient()
on_message = AsyncMock()
c.on('message', on_message)
_run(c._receive_packet(packet.Packet(packet.MESSAGE, {'foo': 'bar'})))
on_message.mock.assert_called_once_with({'foo': 'bar'})
def test_receive_close_packet(self):
c = asyncio_client.AsyncClient()
c.disconnect = AsyncMock()
_run(c._receive_packet(packet.Packet(packet.CLOSE)))
c.disconnect.mock.assert_called_once_with(abort=True)
def test_receive_message_packet(self):
c = asyncio_client.AsyncClient()
c._trigger_event = AsyncMock()
_run(c._receive_packet(packet.Packet(packet.MESSAGE, {'foo': 'bar'})))
c._trigger_event.mock.assert_called_once_with(
'message', {'foo': 'bar'}, run_async=True)
def test_websocket_connection_no_open_packet(self):
asyncio_client.websockets.connect.mock.return_value.recv = AsyncMock(
return_value=packet.Packet(packet.CLOSE).encode())
c = asyncio_client.AsyncClient()
self.assertRaises(exceptions.ConnectionError, _run,
c.connect('http://foo', transports=['websocket']))
def test_is_asyncio_based(self):
c = asyncio_client.AsyncClient()
self.assertEqual(c.is_asyncio_based(), True)
def test_wait_no_task(self):
c = asyncio_client.AsyncClient()
c.read_loop_task = None
_run(c.wait())
def test_invalid_transports(self):
c = asyncio_client.AsyncClient()
self.assertRaises(ValueError, _run,
c.connect('http://foo', transports=['foo', 'bar']))
def test_disconnect_not_connected(self):
c = asyncio_client.AsyncClient()
c.state = 'foo'
_run(c.disconnect())
self.assertEqual(c.state, 'disconnected')
def test_receive_noop_packet(self):
c = asyncio_client.AsyncClient()
_run(c._receive_packet(packet.Packet(packet.NOOP)))
def test_sleep(self):
c = asyncio_client.AsyncClient()
_run(c.sleep(0))
def test_send_packet_disconnected(self):
c = asyncio_client.AsyncClient()
c.queue = c.create_queue()
c.state = 'disconnected'
_run(c._send_packet(packet.Packet(packet.NOOP)))
self.assertTrue(c.queue.empty())
def test_create_queue(self):
c = asyncio_client.AsyncClient()
q = c.create_queue()
self.assertRaises(q.Empty, q.get_nowait)
def test_trigger_unknown_event(self):
c = asyncio_client.AsyncClient()
_run(c._trigger_event('connect', run_async=False))
_run(c._trigger_event('message', 123, run_async=True))
def test_create_event(self):
c = asyncio_client.AsyncClient()
e = c.create_event()
self.assertFalse(e.is_set())
e.set()
self.assertTrue(e.is_set())
def test_write_loop_disconnected(self):
c = asyncio_client.AsyncClient()
c.state = 'disconnected'
_run(c._write_loop())
def test_polling_connection_404(self):
c = asyncio_client.AsyncClient()
c._send_request = AsyncMock()
c._send_request.mock.return_value.status = 404
self.assertRaises(exceptions.ConnectionError, _run,
c.connect('http://foo'))
