michal
/
craftbeerpi3
mirror of https://github.com/Manuel83/craftbeerpi3
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 2 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
168 Commits
10 Branches
273MB
Tree: 996bc54768
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '996bc54768'
${ noResults }
craftbeerpi3/venv/lib/python3.6/site-packages/tests/common/test_client.py

1156 lines
44KB
Raw Blame History 

  1. import json

  2. import logging

  3. import time

  4. import unittest

  5. 

  6. import six

  7. if six.PY3:

  8.     from unittest import mock

  9. else:

  10.     import mock

  11. import websocket

  12. 

  13. from engineio import client

  14. from engineio import exceptions

  15. from engineio import packet

  16. from engineio import payload

  17. 

  18. if six.PY2:

  19.     ConnectionError = OSError

  20. 

  21. 

  22. class TestClient(unittest.TestCase):

  23.     def test_is_asyncio_based(self):

  24.         c = client.Client()

  25.         self.assertEqual(c.is_asyncio_based(), False)

  26. 

  27.     def test_create(self):

  28.         c = client.Client()

  29.         self.assertEqual(c.handlers, {})

  30.         for attr in ['base_url', 'transports', 'sid', 'upgrades',

  31.                      'ping_interval', 'ping_timeout', 'http', 'ws',

  32.                      'read_loop_task', 'write_loop_task', 'queue']:

  33.             self.assertIsNone(getattr(c, attr), attr + ' is not None')

  34.         self.assertTrue(c.pong_received)

  35.         self.assertEqual(c.state, 'disconnected')

  36. 

  37.     def test_custon_json(self):

  38.         client.Client()

  39.         self.assertEqual(packet.Packet.json, json)

  40.         client.Client(json='foo')

  41.         self.assertEqual(packet.Packet.json, 'foo')

  42.         packet.Packet.json = json

  43. 

  44.     def test_logger(self):

  45.         c = client.Client(logger=False)

  46.         self.assertEqual(c.logger.getEffectiveLevel(), logging.ERROR)

  47.         c.logger.setLevel(logging.NOTSET)

  48.         c = client.Client(logger=True)

  49.         self.assertEqual(c.logger.getEffectiveLevel(), logging.INFO)

  50.         c.logger.setLevel(logging.WARNING)

  51.         c = client.Client(logger=True)

  52.         self.assertEqual(c.logger.getEffectiveLevel(), logging.WARNING)

  53.         c.logger.setLevel(logging.NOTSET)

  54.         my_logger = logging.Logger('foo')

  55.         c = client.Client(logger=my_logger)

  56.         self.assertEqual(c.logger, my_logger)

  57. 

  58.     def test_on_event(self):

  59.         c = client.Client()

  60. 

  61.         @c.on('connect')

  62.         def foo():

  63.             pass

  64.         c.on('disconnect', foo)

  65. 

  66.         self.assertEqual(c.handlers['connect'], foo)

  67.         self.assertEqual(c.handlers['disconnect'], foo)

  68. 

  69.     def test_on_event_invalid(self):

  70.         c = client.Client()

  71.         self.assertRaises(ValueError, c.on, 'invalid')

  72. 

  73.     def test_already_connected(self):

  74.         c = client.Client()

  75.         c.state = 'connected'

  76.         self.assertRaises(ValueError, c.connect, 'http://foo')

  77. 

  78.     def test_invalid_transports(self):

  79.         c = client.Client()

  80.         self.assertRaises(ValueError, c.connect, 'http://foo',

  81.                           transports=['foo', 'bar'])

  82. 

  83.     def test_some_invalid_transports(self):

  84.         c = client.Client()

  85.         c._connect_websocket = mock.MagicMock()

  86.         c.connect('http://foo', transports=['foo', 'websocket', 'bar'])

  87.         self.assertEqual(c.transports, ['websocket'])

  88. 

  89.     def test_connect_polling(self):

  90.         c = client.Client()

  91.         c._connect_polling = mock.MagicMock(return_value='foo')

  92.         self.assertEqual(c.connect('http://foo'), 'foo')

  93.         c._connect_polling.assert_called_once_with(

  94.             'http://foo', {}, 'engine.io')

  95. 

  96.         c = client.Client()

  97.         c._connect_polling = mock.MagicMock(return_value='foo')

  98.         self.assertEqual(c.connect('http://foo', transports=['polling']),

  99.                          'foo')

  100.         c._connect_polling.assert_called_once_with(

  101.             'http://foo', {}, 'engine.io')

  102. 

  103.         c = client.Client()

  104.         c._connect_polling = mock.MagicMock(return_value='foo')

  105.         self.assertEqual(c.connect('http://foo',

  106.                                    transports=['polling', 'websocket']),

  107.                          'foo')

  108.         c._connect_polling.assert_called_once_with(

  109.             'http://foo', {}, 'engine.io')

  110. 

  111.     def test_connect_websocket(self):

  112.         c = client.Client()

  113.         c._connect_websocket = mock.MagicMock(return_value='foo')

  114.         self.assertEqual(c.connect('http://foo', transports=['websocket']),

  115.                          'foo')

  116.         c._connect_websocket.assert_called_once_with(

  117.             'http://foo', {}, 'engine.io')

  118. 

  119.         c = client.Client()

  120.         c._connect_websocket = mock.MagicMock(return_value='foo')

  121.         self.assertEqual(c.connect('http://foo', transports='websocket'),

  122.                          'foo')

  123.         c._connect_websocket.assert_called_once_with(

  124.             'http://foo', {}, 'engine.io')

  125. 

  126.     def test_connect_query_string(self):

  127.         c = client.Client()

  128.         c._connect_polling = mock.MagicMock(return_value='foo')

  129.         self.assertEqual(c.connect('http://foo?bar=baz'), 'foo')

  130.         c._connect_polling.assert_called_once_with(

  131.             'http://foo?bar=baz', {}, 'engine.io')

  132. 

  133.     def test_connect_custom_headers(self):

  134.         c = client.Client()

  135.         c._connect_polling = mock.MagicMock(return_value='foo')

  136.         self.assertEqual(c.connect('http://foo', headers={'Foo': 'Bar'}),

  137.                          'foo')

  138.         c._connect_polling.assert_called_once_with(

  139.             'http://foo', {'Foo': 'Bar'}, 'engine.io')

  140. 

  141.     def test_wait(self):

  142.         c = client.Client()

  143.         c.read_loop_task = mock.MagicMock()

  144.         c.wait()

  145.         c.read_loop_task.join.assert_called_once_with()

  146. 

  147.     def test_wait_no_task(self):

  148.         c = client.Client()

  149.         c.read_loop_task = None

  150.         c.wait()  # should not block

  151. 

  152.     def test_send(self):

  153.         c = client.Client()

  154.         saved_packets = []

  155. 

  156.         def fake_send_packet(pkt):

  157.             saved_packets.append(pkt)

  158. 

  159.         c._send_packet = fake_send_packet

  160.         c.send('foo')

  161.         c.send('foo', binary=False)

  162.         c.send(b'foo', binary=True)

  163.         self.assertEqual(saved_packets[0].packet_type, packet.MESSAGE)

  164.         self.assertEqual(saved_packets[0].data, 'foo')

  165.         self.assertEqual(saved_packets[0].binary,

  166.                          False if six.PY3 else True)

  167.         self.assertEqual(saved_packets[1].packet_type, packet.MESSAGE)

  168.         self.assertEqual(saved_packets[1].data, 'foo')

  169.         self.assertEqual(saved_packets[1].binary, False)

  170.         self.assertEqual(saved_packets[2].packet_type, packet.MESSAGE)

  171.         self.assertEqual(saved_packets[2].data, b'foo')

  172.         self.assertEqual(saved_packets[2].binary, True)

  173. 

  174.     def test_disconnect_not_connected(self):

  175.         c = client.Client()

  176.         c.state = 'foo'

  177.         c.sid = 'bar'

  178.         c.disconnect()

  179.         self.assertEqual(c.state, 'disconnected')

  180.         self.assertIsNone(c.sid)

  181. 

  182.     def test_disconnect_polling(self):

  183.         c = client.Client()

  184.         client.connected_clients.append(c)

  185.         c.state = 'connected'

  186.         c.current_transport = 'polling'

  187.         c.queue = mock.MagicMock()

  188.         c.read_loop_task = mock.MagicMock()

  189.         c.ws = mock.MagicMock()

  190.         c._trigger_event = mock.MagicMock()

  191.         c.disconnect()

  192.         c.read_loop_task.join.assert_called_once_with()

  193.         c.ws.mock.assert_not_called()

  194.         self.assertNotIn(c, client.connected_clients)

  195.         c._trigger_event.assert_called_once_with('disconnect',

  196.                                                  run_async=False)

  197. 

  198.     def test_disconnect_websocket(self):

  199.         c = client.Client()

  200.         client.connected_clients.append(c)

  201.         c.state = 'connected'

  202.         c.current_transport = 'websocket'

  203.         c.queue = mock.MagicMock()

  204.         c.read_loop_task = mock.MagicMock()

  205.         c.ws = mock.MagicMock()

  206.         c._trigger_event = mock.MagicMock()

  207.         c.disconnect()

  208.         c.read_loop_task.join.assert_called_once_with()

  209.         c.ws.close.assert_called_once_with()

  210.         self.assertNotIn(c, client.connected_clients)

  211.         c._trigger_event.assert_called_once_with('disconnect',

  212.                                                  run_async=False)

  213. 

  214.     def test_disconnect_polling_abort(self):

  215.         c = client.Client()

  216.         client.connected_clients.append(c)

  217.         c.state = 'connected'

  218.         c.current_transport = 'polling'

  219.         c.queue = mock.MagicMock()

  220.         c.read_loop_task = mock.MagicMock()

  221.         c.ws = mock.MagicMock()

  222.         c.disconnect(abort=True)

  223.         c.queue.join.assert_not_called()

  224.         c.read_loop_task.join.assert_not_called()

  225.         c.ws.mock.assert_not_called()

  226.         self.assertNotIn(c, client.connected_clients)

  227. 

  228.     def test_disconnect_websocket_abort(self):

  229.         c = client.Client()

  230.         client.connected_clients.append(c)

  231.         c.state = 'connected'

  232.         c.current_transport = 'websocket'

  233.         c.queue = mock.MagicMock()

  234.         c.read_loop_task = mock.MagicMock()

  235.         c.ws = mock.MagicMock()

  236.         c.disconnect(abort=True)

  237.         c.queue.join.assert_not_called()

  238.         c.read_loop_task.join.assert_not_called()

  239.         c.ws.mock.assert_not_called()

  240.         self.assertNotIn(c, client.connected_clients)

  241. 

  242.     def test_current_transport(self):

  243.         c = client.Client()

  244.         c.current_transport = 'foo'

  245.         self.assertEqual(c.transport(), 'foo')

  246. 

  247.     def test_background_tasks(self):

  248.         flag = {}

  249. 

  250.         def bg_task():

  251.             flag['task'] = True

  252. 

  253.         c = client.Client()

  254.         task = c.start_background_task(bg_task)

  255.         task.join()

  256.         self.assertIn('task', flag)

  257.         self.assertTrue(flag['task'])

  258. 

  259.     def test_sleep(self):

  260.         c = client.Client()

  261.         t = time.time()

  262.         c.sleep(0.1)

  263.         self.assertTrue(time.time() - t > 0.1)

  264. 

  265.     def test_create_queue(self):

  266.         c = client.Client()

  267.         q = c.create_queue()

  268.         self.assertRaises(q.Empty, q.get, timeout=0.01)

  269. 

  270.     def test_create_event(self):

  271.         c = client.Client()

  272.         e = c.create_event()

  273.         self.assertFalse(e.is_set())

  274.         e.set()

  275.         self.assertTrue(e.is_set())

  276. 

  277.     @mock.patch('engineio.client.time.time', return_value=123.456)

  278.     @mock.patch('engineio.client.Client._send_request', return_value=None)

  279.     def test_polling_connection_failed(self, _send_request, _time):

  280.         c = client.Client()

  281.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo',

  282.                           headers={'Foo': 'Bar'})

  283.         _send_request.assert_called_once_with(

  284.             'GET', 'http://foo/engine.io/?transport=polling&EIO=3&t=123.456',

  285.             headers={'Foo': 'Bar'})

  286. 

  287.     @mock.patch('engineio.client.Client._send_request')

  288.     def test_polling_connection_404(self, _send_request):

  289.         _send_request.return_value.status_code = 404

  290.         c = client.Client()

  291.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo')

  292. 

  293.     @mock.patch('engineio.client.Client._send_request')

  294.     def test_polling_connection_invalid_packet(self, _send_request):

  295.         _send_request.return_value.status_code = 200

  296.         _send_request.return_value.content = b'foo'

  297.         c = client.Client()

  298.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo')

  299. 

  300.     @mock.patch('engineio.client.Client._send_request')

  301.     def test_polling_connection_no_open_packet(self, _send_request):

  302.         _send_request.return_value.status_code = 200

  303.         _send_request.return_value.content = payload.Payload(packets=[

  304.             packet.Packet(packet.CLOSE, {

  305.                 'sid': '123', 'upgrades': [], 'pingInterval': 10,

  306.                 'pingTimeout': 20

  307.             })

  308.         ]).encode()

  309.         c = client.Client()

  310.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo')

  311. 

  312.     @mock.patch('engineio.client.Client._send_request')

  313.     def test_polling_connection_successful(self, _send_request):

  314.         _send_request.return_value.status_code = 200

  315.         _send_request.return_value.content = payload.Payload(packets=[

  316.             packet.Packet(packet.OPEN, {

  317.                 'sid': '123', 'upgrades': [], 'pingInterval': 1000,

  318.                 'pingTimeout': 2000

  319.             })

  320.         ]).encode()

  321.         c = client.Client()

  322.         c._ping_loop = mock.MagicMock()

  323.         c._read_loop_polling = mock.MagicMock()

  324.         c._read_loop_websocket = mock.MagicMock()

  325.         c._write_loop = mock.MagicMock()

  326.         on_connect = mock.MagicMock()

  327.         c.on('connect', on_connect)

  328.         c.connect('http://foo')

  329.         time.sleep(0.1)

  330. 

  331.         c._ping_loop.assert_called_once_with()

  332.         c._read_loop_polling.assert_called_once_with()

  333.         c._read_loop_websocket.assert_not_called()

  334.         c._write_loop.assert_called_once_with()

  335.         on_connect.assert_called_once_with()

  336.         self.assertIn(c, client.connected_clients)

  337.         self.assertEqual(

  338.             c.base_url,

  339.             'http://foo/engine.io/?transport=polling&EIO=3&sid=123')

  340.         self.assertEqual(c.sid, '123')

  341.         self.assertEqual(c.ping_interval, 1)

  342.         self.assertEqual(c.ping_timeout, 2)

  343.         self.assertEqual(c.upgrades, [])

  344.         self.assertEqual(c.transport(), 'polling')

  345. 

  346.     @mock.patch('engineio.client.Client._send_request')

  347.     def test_polling_connection_with_more_packets(self, _send_request):

  348.         _send_request.return_value.status_code = 200

  349.         _send_request.return_value.content = payload.Payload(packets=[

  350.             packet.Packet(packet.OPEN, {

  351.                 'sid': '123', 'upgrades': [], 'pingInterval': 1000,

  352.                 'pingTimeout': 2000

  353.             }),

  354.             packet.Packet(packet.NOOP)

  355.         ]).encode()

  356.         c = client.Client()

  357.         c._ping_loop = mock.MagicMock()

  358.         c._read_loop_polling = mock.MagicMock()

  359.         c._read_loop_websocket = mock.MagicMock()

  360.         c._write_loop = mock.MagicMock()

  361.         c._receive_packet = mock.MagicMock()

  362.         on_connect = mock.MagicMock()

  363.         c.on('connect', on_connect)

  364.         c.connect('http://foo')

  365.         time.sleep(0.1)

  366.         self.assertEqual(c._receive_packet.call_count, 1)

  367.         self.assertEqual(

  368.             c._receive_packet.call_args_list[0][0][0].packet_type,

  369.             packet.NOOP)

  370. 

  371.     @mock.patch('engineio.client.Client._send_request')

  372.     def test_polling_connection_upgraded(self, _send_request):

  373.         _send_request.return_value.status_code = 200

  374.         _send_request.return_value.content = payload.Payload(packets=[

  375.             packet.Packet(packet.OPEN, {

  376.                 'sid': '123', 'upgrades': ['websocket'], 'pingInterval': 1000,

  377.                 'pingTimeout': 2000

  378.             })

  379.         ]).encode()

  380.         c = client.Client()

  381.         c._connect_websocket = mock.MagicMock(return_value=True)

  382.         on_connect = mock.MagicMock()

  383.         c.on('connect', on_connect)

  384.         c.connect('http://foo')

  385. 

  386.         c._connect_websocket.assert_called_once_with('http://foo', {},

  387.                                                      'engine.io')

  388.         on_connect.assert_called_once_with()

  389.         self.assertIn(c, client.connected_clients)

  390.         self.assertEqual(

  391.             c.base_url,

  392.             'http://foo/engine.io/?transport=polling&EIO=3&sid=123')

  393.         self.assertEqual(c.sid, '123')

  394.         self.assertEqual(c.ping_interval, 1)

  395.         self.assertEqual(c.ping_timeout, 2)

  396.         self.assertEqual(c.upgrades, ['websocket'])

  397. 

  398.     @mock.patch('engineio.client.Client._send_request')

  399.     def test_polling_connection_not_upgraded(self, _send_request):

  400.         _send_request.return_value.status_code = 200

  401.         _send_request.return_value.content = payload.Payload(packets=[

  402.             packet.Packet(packet.OPEN, {

  403.                 'sid': '123', 'upgrades': ['websocket'], 'pingInterval': 1000,

  404.                 'pingTimeout': 2000

  405.             })

  406.         ]).encode()

  407.         c = client.Client()

  408.         c._connect_websocket = mock.MagicMock(return_value=False)

  409.         c._ping_loop = mock.MagicMock()

  410.         c._read_loop_polling = mock.MagicMock()

  411.         c._read_loop_websocket = mock.MagicMock()

  412.         c._write_loop = mock.MagicMock()

  413.         on_connect = mock.MagicMock()

  414.         c.on('connect', on_connect)

  415.         c.connect('http://foo')

  416.         time.sleep(0.1)

  417. 

  418.         c._connect_websocket.assert_called_once_with('http://foo', {},

  419.                                                      'engine.io')

  420.         c._ping_loop.assert_called_once_with()

  421.         c._read_loop_polling.assert_called_once_with()

  422.         c._read_loop_websocket.assert_not_called()

  423.         c._write_loop.assert_called_once_with()

  424.         on_connect.assert_called_once_with()

  425.         self.assertIn(c, client.connected_clients)

  426. 

  427.     @mock.patch('engineio.client.time.time', return_value=123.456)

  428.     @mock.patch('engineio.client.websocket.create_connection',

  429.                 side_effect=[ConnectionError])

  430.     def test_websocket_connection_failed(self, create_connection, _time):

  431.         c = client.Client()

  432.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo',

  433.                           transports=['websocket'], headers={'Foo': 'Bar'})

  434.         create_connection.assert_called_once_with(

  435.             'ws://foo/engine.io/?transport=websocket&EIO=3&t=123.456',

  436.             header={'Foo': 'Bar'}, cookie=None)

  437. 

  438.     @mock.patch('engineio.client.time.time', return_value=123.456)

  439.     @mock.patch('engineio.client.websocket.create_connection',

  440.                 side_effect=[ConnectionError])

  441.     def test_websocket_upgrade_failed(self, create_connection, _time):

  442.         c = client.Client()

  443.         c.sid = '123'

  444.         self.assertFalse(c.connect('http://foo', transports=['websocket']))

  445.         create_connection.assert_called_once_with(

  446.             'ws://foo/engine.io/?transport=websocket&EIO=3&sid=123&t=123.456',

  447.             header={}, cookie=None)

  448. 

  449.     @mock.patch('engineio.client.websocket.create_connection')

  450.     def test_websocket_connection_no_open_packet(self, create_connection):

  451.         create_connection.return_value.recv.return_value = packet.Packet(

  452.             packet.CLOSE).encode()

  453.         c = client.Client()

  454.         self.assertRaises(exceptions.ConnectionError, c.connect, 'http://foo',

  455.                           transports=['websocket'])

  456. 

  457.     @mock.patch('engineio.client.websocket.create_connection')

  458.     def test_websocket_connection_successful(self, create_connection):

  459.         create_connection.return_value.recv.return_value = packet.Packet(

  460.             packet.OPEN, {

  461.                 'sid': '123', 'upgrades': [], 'pingInterval': 1000,

  462.                 'pingTimeout': 2000

  463.             }).encode()

  464.         c = client.Client()

  465.         c._ping_loop = mock.MagicMock()

  466.         c._read_loop_polling = mock.MagicMock()

  467.         c._read_loop_websocket = mock.MagicMock()

  468.         c._write_loop = mock.MagicMock()

  469.         on_connect = mock.MagicMock()

  470.         c.on('connect', on_connect)

  471.         c.connect('ws://foo', transports=['websocket'])

  472.         time.sleep(0.1)

  473. 

  474.         c._ping_loop.assert_called_once_with()

  475.         c._read_loop_polling.assert_not_called()

  476.         c._read_loop_websocket.assert_called_once_with()

  477.         c._write_loop.assert_called_once_with()

  478.         on_connect.assert_called_once_with()

  479.         self.assertIn(c, client.connected_clients)

  480.         self.assertEqual(

  481.             c.base_url,

  482.             'ws://foo/engine.io/?transport=websocket&EIO=3')

  483.         self.assertEqual(c.sid, '123')

  484.         self.assertEqual(c.ping_interval, 1)

  485.         self.assertEqual(c.ping_timeout, 2)

  486.         self.assertEqual(c.upgrades, [])

  487.         self.assertEqual(c.transport(), 'websocket')

  488.         self.assertEqual(c.ws, create_connection.return_value)

  489.         self.assertEqual(len(create_connection.call_args_list), 1)

  490.         self.assertEqual(create_connection.call_args[1],

  491.                          {'header': {}, 'cookie': None})

  492. 

  493.     @mock.patch('engineio.client.websocket.create_connection')

  494.     def test_websocket_connection_with_cookies(self, create_connection):

  495.         create_connection.return_value.recv.return_value = packet.Packet(

  496.             packet.OPEN, {

  497.                 'sid': '123', 'upgrades': [], 'pingInterval': 1000,

  498.                 'pingTimeout': 2000

  499.             }).encode()

  500.         c = client.Client()

  501.         c.http = mock.MagicMock()

  502.         c.http.cookies = [mock.MagicMock(), mock.MagicMock()]

  503.         c.http.cookies[0].name = 'key'

  504.         c.http.cookies[0].value = 'value'

  505.         c.http.cookies[1].name = 'key2'

  506.         c.http.cookies[1].value = 'value2'

  507.         c._ping_loop = mock.MagicMock()

  508.         c._read_loop_polling = mock.MagicMock()

  509.         c._read_loop_websocket = mock.MagicMock()

  510.         c._write_loop = mock.MagicMock()

  511.         on_connect = mock.MagicMock()

  512.         c.on('connect', on_connect)

  513.         c.connect('ws://foo', transports=['websocket'])

  514.         time.sleep(0.1)

  515. 

  516.         self.assertEqual(len(create_connection.call_args_list), 1)

  517.         self.assertEqual(create_connection.call_args[1],

  518.                          {'header': {}, 'cookie': 'key=value; key2=value2'})

  519. 

  520.     @mock.patch('engineio.client.websocket.create_connection')

  521.     def test_websocket_upgrade_no_pong(self, create_connection):

  522.         create_connection.return_value.recv.return_value = packet.Packet(

  523.             packet.OPEN, {

  524.                 'sid': '123', 'upgrades': [], 'pingInterval': 1000,

  525.                 'pingTimeout': 2000

  526.             }).encode()

  527.         c = client.Client()

  528.         c.sid = '123'

  529.         c.current_transport = 'polling'

  530.         c._ping_loop = mock.MagicMock()

  531.         c._read_loop_polling = mock.MagicMock()

  532.         c._read_loop_websocket = mock.MagicMock()

  533.         c._write_loop = mock.MagicMock()

  534.         on_connect = mock.MagicMock()

  535.         c.on('connect', on_connect)

  536.         self.assertFalse(c.connect('ws://foo', transports=['websocket']))

  537. 

  538.         c._ping_loop.assert_not_called()

  539.         c._read_loop_polling.assert_not_called()

  540.         c._read_loop_websocket.assert_not_called()

  541.         c._write_loop.assert_not_called()

  542.         on_connect.assert_not_called()

  543.         self.assertEqual(c.transport(), 'polling')

  544. 

  545.     @mock.patch('engineio.client.websocket.create_connection')

  546.     def test_websocket_upgrade_successful(self, create_connection):

  547.         create_connection.return_value.recv.return_value = packet.Packet(

  548.             packet.PONG, six.text_type('probe')).encode()

  549.         c = client.Client()

  550.         c.sid = '123'

  551.         c.base_url = 'http://foo'

  552.         c.current_transport = 'polling'

  553.         c._ping_loop = mock.MagicMock()

  554.         c._read_loop_polling = mock.MagicMock()

  555.         c._read_loop_websocket = mock.MagicMock()

  556.         c._write_loop = mock.MagicMock()

  557.         on_connect = mock.MagicMock()

  558.         c.on('connect', on_connect)

  559.         self.assertTrue(c.connect('ws://foo', transports=['websocket']))

  560.         time.sleep(0.1)

  561. 

  562.         c._ping_loop.assert_called_once_with()

  563.         c._read_loop_polling.assert_not_called()

  564.         c._read_loop_websocket.assert_called_once_with()

  565.         c._write_loop.assert_called_once_with()

  566.         on_connect.assert_not_called()  # was called by polling

  567.         self.assertNotIn(c, client.connected_clients)  # was added by polling

  568.         self.assertEqual(c.base_url, 'http://foo')  # not changed

  569.         self.assertEqual(c.sid, '123')  # not changed

  570.         self.assertEqual(c.transport(), 'websocket')

  571.         self.assertEqual(c.ws, create_connection.return_value)

  572.         self.assertEqual(

  573.             create_connection.return_value.send.call_args_list[0],

  574.             ((packet.Packet(packet.PING, six.text_type('probe')).encode(),),)

  575.         )  # ping

  576.         self.assertEqual(

  577.             create_connection.return_value.send.call_args_list[1],

  578.             ((packet.Packet(packet.UPGRADE).encode(),),))  # upgrade

  579. 

  580.     def test_receive_unknown_packet(self):

  581.         c = client.Client()

  582.         c._receive_packet(packet.Packet(encoded_packet=b'9'))

  583.         # should be ignored

  584. 

  585.     def test_receive_noop_packet(self):

  586.         c = client.Client()

  587.         c._receive_packet(packet.Packet(packet.NOOP))

  588.         # should be ignored

  589. 

  590.     def test_receive_pong_packet(self):

  591.         c = client.Client()

  592.         c.pong_received = False

  593.         c._receive_packet(packet.Packet(packet.PONG))

  594.         self.assertTrue(c.pong_received)

  595. 

  596.     def test_receive_message_packet(self):

  597.         c = client.Client()

  598.         c._trigger_event = mock.MagicMock()

  599.         c._receive_packet(packet.Packet(packet.MESSAGE, {'foo': 'bar'}))

  600.         c._trigger_event.assert_called_once_with('message', {'foo': 'bar'},

  601.                                                  run_async=True)

  602. 

  603.     def test_receive_close_packet(self):

  604.         c = client.Client()

  605.         c.disconnect = mock.MagicMock()

  606.         c._receive_packet(packet.Packet(packet.CLOSE))

  607.         c.disconnect.assert_called_once_with(abort=True)

  608. 

  609.     def test_send_packet_disconnected(self):

  610.         c = client.Client()

  611.         c.queue = c.create_queue()

  612.         c.state = 'disconnected'

  613.         c._send_packet(packet.Packet(packet.NOOP))

  614.         self.assertTrue(c.queue.empty())

  615. 

  616.     def test_send_packet(self):

  617.         c = client.Client()

  618.         c.queue = c.create_queue()

  619.         c.state = 'connected'

  620.         c._send_packet(packet.Packet(packet.NOOP))

  621.         self.assertFalse(c.queue.empty())

  622.         pkt = c.queue.get()

  623.         self.assertEqual(pkt.packet_type, packet.NOOP)

  624. 

  625.     def test_trigger_event(self):

  626.         c = client.Client()

  627.         f = {}

  628. 

  629.         @c.on('connect')

  630.         def foo():

  631.             return 'foo'

  632. 

  633.         @c.on('message')

  634.         def bar(data):

  635.             f['bar'] = data

  636.             return 'bar'

  637. 

  638.         r = c._trigger_event('connect', run_async=False)

  639.         self.assertEqual(r, 'foo')

  640.         r = c._trigger_event('message', 123, run_async=True)

  641.         r.join()

  642.         self.assertEqual(f['bar'], 123)

  643.         r = c._trigger_event('message', 321)

  644.         self.assertEqual(r, 'bar')

  645. 

  646.     def test_trigger_unknown_event(self):

  647.         c = client.Client()

  648.         c._trigger_event('connect', run_async=False)

  649.         c._trigger_event('message', 123, run_async=True)

  650.         # should do nothing

  651. 

  652.     def test_trigger_event_error(self):

  653.         c = client.Client()

  654. 

  655.         @c.on('connect')

  656.         def foo():

  657.             return 1 / 0

  658. 

  659.         @c.on('message')

  660.         def bar(data):

  661.             return 1 / 0

  662. 

  663.         r = c._trigger_event('connect', run_async=False)

  664.         self.assertEqual(r, None)

  665.         r = c._trigger_event('message', 123, run_async=False)

  666.         self.assertEqual(r, None)

  667. 

  668.     def test_engineio_url(self):

  669.         c = client.Client()

  670.         self.assertEqual(

  671.             c._get_engineio_url('http://foo', 'bar', 'polling'),

  672.             'http://foo/bar/?transport=polling&EIO=3')

  673.         self.assertEqual(

  674.             c._get_engineio_url('http://foo', 'bar', 'websocket'),

  675.             'ws://foo/bar/?transport=websocket&EIO=3')

  676.         self.assertEqual(

  677.             c._get_engineio_url('ws://foo', 'bar', 'polling'),

  678.             'http://foo/bar/?transport=polling&EIO=3')

  679.         self.assertEqual(

  680.             c._get_engineio_url('ws://foo', 'bar', 'websocket'),

  681.             'ws://foo/bar/?transport=websocket&EIO=3')

  682.         self.assertEqual(

  683.             c._get_engineio_url('https://foo', 'bar', 'polling'),

  684.             'https://foo/bar/?transport=polling&EIO=3')

  685.         self.assertEqual(

  686.             c._get_engineio_url('https://foo', 'bar', 'websocket'),

  687.             'wss://foo/bar/?transport=websocket&EIO=3')

  688.         self.assertEqual(

  689.             c._get_engineio_url('http://foo?baz=1', 'bar', 'polling'),

  690.             'http://foo/bar/?baz=1&transport=polling&EIO=3')

  691.         self.assertEqual(

  692.             c._get_engineio_url('http://foo#baz', 'bar', 'polling'),

  693.             'http://foo/bar/?transport=polling&EIO=3')

  694. 

  695.     def test_ping_loop_disconnected(self):

  696.         c = client.Client()

  697.         c.state = 'disconnected'

  698.         c._ping_loop()

  699.         # should not block

  700. 

  701.     def test_ping_loop_disconnect(self):

  702.         c = client.Client()

  703.         c.state = 'connected'

  704.         c.ping_interval = 10

  705.         c._send_packet = mock.MagicMock()

  706. 

  707.         states = [

  708.             ('disconnecting', True)

  709.         ]

  710. 

  711.         def fake_wait(timeout):

  712.             self.assertEqual(timeout, 10)

  713.             c.state, c.pong_received = states.pop(0)

  714. 

  715.         c.ping_loop_event.wait = fake_wait

  716.         c._ping_loop()

  717.         self.assertEqual(

  718.             c._send_packet.call_args_list[0][0][0].encode(), b'2')

  719. 

  720.     def test_ping_loop_missing_pong(self):

  721.         c = client.Client()

  722.         c.state = 'connected'

  723.         c.ping_interval = 10

  724.         c._send_packet = mock.MagicMock()

  725.         c.queue = mock.MagicMock()

  726. 

  727.         states = [

  728.             ('connected', False)

  729.         ]

  730. 

  731.         def fake_wait(timeout):

  732.             self.assertEqual(timeout, 10)

  733.             c.state, c.pong_received = states.pop(0)

  734. 

  735.         c.ping_loop_event.wait = fake_wait

  736.         c._ping_loop()

  737.         self.assertEqual(c.state, 'connected')

  738.         c.queue.put.assert_called_once_with(None)

  739. 

  740.     def test_ping_loop_missing_pong_websocket(self):

  741.         c = client.Client()

  742.         c.state = 'connected'

  743.         c.ping_interval = 10

  744.         c._send_packet = mock.MagicMock()

  745.         c.queue = mock.MagicMock()

  746.         c.ws = mock.MagicMock()

  747. 

  748.         states = [

  749.             ('connected', False)

  750.         ]

  751. 

  752.         def fake_wait(timeout):

  753.             self.assertEqual(timeout, 10)

  754.             c.state, c.pong_received = states.pop(0)

  755. 

  756.         c.ping_loop_event.wait = fake_wait

  757.         c._ping_loop()

  758.         self.assertEqual(c.state, 'connected')

  759.         c.queue.put.assert_called_once_with(None)

  760.         c.ws.close.assert_called_once_with()

  761. 

  762.     def test_read_loop_polling_disconnected(self):

  763.         c = client.Client()

  764.         c.state = 'disconnected'

  765.         c._trigger_event = mock.MagicMock()

  766.         c.write_loop_task = mock.MagicMock()

  767.         c.ping_loop_task = mock.MagicMock()

  768.         c._read_loop_polling()

  769.         c.write_loop_task.join.assert_called_once_with()

  770.         c.ping_loop_task.join.assert_called_once_with()

  771.         c._trigger_event.assert_not_called()

  772. 

  773.     @mock.patch('engineio.client.time.time', return_value=123.456)

  774.     def test_read_loop_polling_no_response(self, _time):

  775.         c = client.Client()

  776.         c.state = 'connected'

  777.         c.base_url = 'http://foo'

  778.         c.queue = mock.MagicMock()

  779.         c._send_request = mock.MagicMock(return_value=None)

  780.         c._trigger_event = mock.MagicMock()

  781.         c.write_loop_task = mock.MagicMock()

  782.         c.ping_loop_task = mock.MagicMock()

  783.         c._read_loop_polling()

  784.         self.assertEqual(c.state, 'disconnected')

  785.         c.queue.put.assert_called_once_with(None)

  786.         c.write_loop_task.join.assert_called_once_with()

  787.         c.ping_loop_task.join.assert_called_once_with()

  788.         c._send_request.assert_called_once_with('GET', 'http://foo&t=123.456')

  789.         c._trigger_event.assert_called_once_with('disconnect',

  790.                                                  run_async=False)

  791. 

  792.     @mock.patch('engineio.client.time.time', return_value=123.456)

  793.     def test_read_loop_polling_bad_status(self, _time):

  794.         c = client.Client()

  795.         c.state = 'connected'

  796.         c.base_url = 'http://foo'

  797.         c.queue = mock.MagicMock()

  798.         c._send_request = mock.MagicMock()

  799.         c._send_request.return_value.status_code = 400

  800.         c.write_loop_task = mock.MagicMock()

  801.         c.ping_loop_task = mock.MagicMock()

  802.         c._read_loop_polling()

  803.         self.assertEqual(c.state, 'disconnected')

  804.         c.queue.put.assert_called_once_with(None)

  805.         c.write_loop_task.join.assert_called_once_with()

  806.         c.ping_loop_task.join.assert_called_once_with()

  807.         c._send_request.assert_called_once_with('GET', 'http://foo&t=123.456')

  808. 

  809.     @mock.patch('engineio.client.time.time', return_value=123.456)

  810.     def test_read_loop_polling_bad_packet(self, _time):

  811.         c = client.Client()

  812.         c.state = 'connected'

  813.         c.base_url = 'http://foo'

  814.         c.queue = mock.MagicMock()

  815.         c._send_request = mock.MagicMock()

  816.         c._send_request.return_value.status_code = 200

  817.         c._send_request.return_value.content = b'foo'

  818.         c.write_loop_task = mock.MagicMock()

  819.         c.ping_loop_task = mock.MagicMock()

  820.         c._read_loop_polling()

  821.         self.assertEqual(c.state, 'disconnected')

  822.         c.queue.put.assert_called_once_with(None)

  823.         c.write_loop_task.join.assert_called_once_with()

  824.         c.ping_loop_task.join.assert_called_once_with()

  825.         c._send_request.assert_called_once_with('GET', 'http://foo&t=123.456')

  826. 

  827.     def test_read_loop_polling(self):

  828.         c = client.Client()

  829.         c.state = 'connected'

  830.         c.base_url = 'http://foo'

  831.         c.queue = mock.MagicMock()

  832.         c._send_request = mock.MagicMock()

  833.         c._send_request.side_effect = [

  834.             mock.MagicMock(status_code=200, content=payload.Payload(packets=[

  835.                 packet.Packet(packet.PING),

  836.                 packet.Packet(packet.NOOP)]).encode()),

  837.             None

  838.         ]

  839.         c.write_loop_task = mock.MagicMock()

  840.         c.ping_loop_task = mock.MagicMock()

  841.         c._receive_packet = mock.MagicMock()

  842.         c._read_loop_polling()

  843.         self.assertEqual(c.state, 'disconnected')

  844.         c.queue.put.assert_called_once_with(None)

  845.         self.assertEqual(c._send_request.call_count, 2)

  846.         self.assertEqual(c._receive_packet.call_count, 2)

  847.         self.assertEqual(c._receive_packet.call_args_list[0][0][0].encode(),

  848.                          b'2')

  849.         self.assertEqual(c._receive_packet.call_args_list[1][0][0].encode(),

  850.                          b'6')

  851. 

  852.     def test_read_loop_websocket_disconnected(self):

  853.         c = client.Client()

  854.         c.state = 'disconnected'

  855.         c.write_loop_task = mock.MagicMock()

  856.         c.ping_loop_task = mock.MagicMock()

  857.         c._read_loop_websocket()

  858.         c.write_loop_task.join.assert_called_once_with()

  859.         c.ping_loop_task.join.assert_called_once_with()

  860. 

  861.     def test_read_loop_websocket_no_response(self):

  862.         c = client.Client()

  863.         c.state = 'connected'

  864.         c.queue = mock.MagicMock()

  865.         c.ws = mock.MagicMock()

  866.         c.ws.recv.side_effect = websocket.WebSocketConnectionClosedException

  867.         c.write_loop_task = mock.MagicMock()

  868.         c.ping_loop_task = mock.MagicMock()

  869.         c._read_loop_websocket()

  870.         self.assertEqual(c.state, 'disconnected')

  871.         c.queue.put.assert_called_once_with(None)

  872.         c.write_loop_task.join.assert_called_once_with()

  873.         c.ping_loop_task.join.assert_called_once_with()

  874. 

  875.     def test_read_loop_websocket_unexpected_error(self):

  876.         c = client.Client()

  877.         c.state = 'connected'

  878.         c.queue = mock.MagicMock()

  879.         c.ws = mock.MagicMock()

  880.         c.ws.recv.side_effect = ValueError

  881.         c.write_loop_task = mock.MagicMock()

  882.         c.ping_loop_task = mock.MagicMock()

  883.         c._read_loop_websocket()

  884.         self.assertEqual(c.state, 'disconnected')

  885.         c.queue.put.assert_called_once_with(None)

  886.         c.write_loop_task.join.assert_called_once_with()

  887.         c.ping_loop_task.join.assert_called_once_with()

  888. 

  889.     def test_read_loop_websocket(self):

  890.         c = client.Client()

  891.         c.state = 'connected'

  892.         c.queue = mock.MagicMock()

  893.         c.ws = mock.MagicMock()

  894.         c.ws.recv.side_effect = [packet.Packet(packet.PING).encode(),

  895.                                  ValueError]

  896.         c.write_loop_task = mock.MagicMock()

  897.         c.ping_loop_task = mock.MagicMock()

  898.         c._receive_packet = mock.MagicMock()

  899.         c._read_loop_websocket()

  900.         self.assertEqual(c.state, 'disconnected')

  901.         c.queue.put.assert_called_once_with(None)

  902.         c.write_loop_task.join.assert_called_once_with()

  903.         c.ping_loop_task.join.assert_called_once_with()

  904.         self.assertEqual(c._receive_packet.call_args_list[0][0][0].encode(),

  905.                          b'2')

  906. 

  907.     def test_write_loop_disconnected(self):

  908.         c = client.Client()

  909.         c.state = 'disconnected'

  910.         c._write_loop()

  911.         # should not block

  912. 

  913.     def test_write_loop_no_packets(self):

  914.         c = client.Client()

  915.         c.state = 'connected'

  916.         c.ping_interval = 1

  917.         c.ping_timeout = 2

  918.         c.queue = mock.MagicMock()

  919.         c.queue.get.return_value = None

  920.         c._write_loop()

  921.         c.queue.task_done.assert_called_once_with()

  922.         c.queue.get.assert_called_once_with(timeout=7)

  923. 

  924.     def test_write_loop_empty_queue(self):

  925.         c = client.Client()

  926.         c.state = 'connected'

  927.         c.ping_interval = 1

  928.         c.ping_timeout = 2

  929.         c.queue = mock.MagicMock()

  930.         c.queue.Empty = RuntimeError

  931.         c.queue.get.side_effect = RuntimeError

  932.         c._write_loop()

  933.         c.queue.get.assert_called_once_with(timeout=7)

  934. 

  935.     def test_write_loop_polling_one_packet(self):

  936.         c = client.Client()

  937.         c.base_url = 'http://foo'

  938.         c.state = 'connected'

  939.         c.ping_interval = 1

  940.         c.ping_timeout = 2

  941.         c.current_transport = 'polling'

  942.         c.queue = mock.MagicMock()

  943.         c.queue.Empty = RuntimeError

  944.         c.queue.get.side_effect = [

  945.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  946.             RuntimeError,

  947.             RuntimeError

  948.         ]

  949.         c._send_request = mock.MagicMock()

  950.         c._send_request.return_value.status_code = 200

  951.         c._write_loop()

  952.         self.assertEqual(c.queue.task_done.call_count, 1)

  953.         p = payload.Payload(

  954.             packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})])

  955.         c._send_request.assert_called_once_with(

  956.             'POST', 'http://foo', body=p.encode(),

  957.             headers={'Content-Type': 'application/octet-stream'})

  958. 

  959.     def test_write_loop_polling_three_packets(self):

  960.         c = client.Client()

  961.         c.base_url = 'http://foo'

  962.         c.state = 'connected'

  963.         c.ping_interval = 1

  964.         c.ping_timeout = 2

  965.         c.current_transport = 'polling'

  966.         c.queue = mock.MagicMock()

  967.         c.queue.Empty = RuntimeError

  968.         c.queue.get.side_effect = [

  969.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  970.             packet.Packet(packet.PING),

  971.             packet.Packet(packet.NOOP),

  972.             RuntimeError,

  973.             RuntimeError

  974.         ]

  975.         c._send_request = mock.MagicMock()

  976.         c._send_request.return_value.status_code = 200

  977.         c._write_loop()

  978.         self.assertEqual(c.queue.task_done.call_count, 3)

  979.         p = payload.Payload(packets=[

  980.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  981.             packet.Packet(packet.PING),

  982.             packet.Packet(packet.NOOP),

  983.         ])

  984.         c._send_request.assert_called_once_with(

  985.             'POST', 'http://foo', body=p.encode(),

  986.             headers={'Content-Type': 'application/octet-stream'})

  987. 

  988.     def test_write_loop_polling_two_packets_done(self):

  989.         c = client.Client()

  990.         c.base_url = 'http://foo'

  991.         c.state = 'connected'

  992.         c.ping_interval = 1

  993.         c.ping_timeout = 2

  994.         c.current_transport = 'polling'

  995.         c.queue = mock.MagicMock()

  996.         c.queue.Empty = RuntimeError

  997.         c.queue.get.side_effect = [

  998.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  999.             packet.Packet(packet.PING),

  1000.             None,

  1001.             RuntimeError

  1002.         ]

  1003.         c._send_request = mock.MagicMock()

  1004.         c._send_request.return_value.status_code = 200

  1005.         c._write_loop()

  1006.         self.assertEqual(c.queue.task_done.call_count, 3)

  1007.         p = payload.Payload(packets=[

  1008.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1009.             packet.Packet(packet.PING),

  1010.         ])

  1011.         c._send_request.assert_called_once_with(

  1012.             'POST', 'http://foo', body=p.encode(),

  1013.             headers={'Content-Type': 'application/octet-stream'})

  1014.         self.assertEqual(c.state, 'connected')

  1015. 

  1016.     def test_write_loop_polling_bad_connection(self):

  1017.         c = client.Client()

  1018.         c.base_url = 'http://foo'

  1019.         c.state = 'connected'

  1020.         c.ping_interval = 1

  1021.         c.ping_timeout = 2

  1022.         c.current_transport = 'polling'

  1023.         c.queue = mock.MagicMock()

  1024.         c.queue.Empty = RuntimeError

  1025.         c.queue.get.side_effect = [

  1026.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1027.             RuntimeError,

  1028.         ]

  1029.         c._send_request = mock.MagicMock()

  1030.         c._send_request.return_value = None

  1031.         c._write_loop()

  1032.         self.assertEqual(c.queue.task_done.call_count, 1)

  1033.         p = payload.Payload(

  1034.             packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})])

  1035.         c._send_request.assert_called_once_with(

  1036.             'POST', 'http://foo', body=p.encode(),

  1037.             headers={'Content-Type': 'application/octet-stream'})

  1038.         self.assertEqual(c.state, 'connected')

  1039. 

  1040.     def test_write_loop_polling_bad_status(self):

  1041.         c = client.Client()

  1042.         c.base_url = 'http://foo'

  1043.         c.state = 'connected'

  1044.         c.ping_interval = 1

  1045.         c.ping_timeout = 2

  1046.         c.current_transport = 'polling'

  1047.         c.queue = mock.MagicMock()

  1048.         c.queue.Empty = RuntimeError

  1049.         c.queue.get.side_effect = [

  1050.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1051.             RuntimeError,

  1052.         ]

  1053.         c._send_request = mock.MagicMock()

  1054.         c._send_request.return_value.status_code = 500

  1055.         c._write_loop()

  1056.         self.assertEqual(c.queue.task_done.call_count, 1)

  1057.         p = payload.Payload(

  1058.             packets=[packet.Packet(packet.MESSAGE, {'foo': 'bar'})])

  1059.         c._send_request.assert_called_once_with(

  1060.             'POST', 'http://foo', body=p.encode(),

  1061.             headers={'Content-Type': 'application/octet-stream'})

  1062.         self.assertEqual(c.state, 'disconnected')

  1063. 

  1064.     def test_write_loop_websocket_one_packet(self):

  1065.         c = client.Client()

  1066.         c.state = 'connected'

  1067.         c.ping_interval = 1

  1068.         c.ping_timeout = 2

  1069.         c.current_transport = 'websocket'

  1070.         c.queue = mock.MagicMock()

  1071.         c.queue.Empty = RuntimeError

  1072.         c.queue.get.side_effect = [

  1073.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1074.             RuntimeError,

  1075.             RuntimeError

  1076.         ]

  1077.         c.ws = mock.MagicMock()

  1078.         c._write_loop()

  1079.         self.assertEqual(c.queue.task_done.call_count, 1)

  1080.         self.assertEqual(c.ws.send.call_count, 1)

  1081.         self.assertEqual(c.ws.send_binary.call_count, 0)

  1082.         c.ws.send.assert_called_once_with('4{"foo":"bar"}')

  1083. 

  1084.     def test_write_loop_websocket_three_packets(self):

  1085.         c = client.Client()

  1086.         c.state = 'connected'

  1087.         c.ping_interval = 1

  1088.         c.ping_timeout = 2

  1089.         c.current_transport = 'websocket'

  1090.         c.queue = mock.MagicMock()

  1091.         c.queue.Empty = RuntimeError

  1092.         c.queue.get.side_effect = [

  1093.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1094.             packet.Packet(packet.PING),

  1095.             packet.Packet(packet.NOOP),

  1096.             RuntimeError,

  1097.             RuntimeError

  1098.         ]

  1099.         c.ws = mock.MagicMock()

  1100.         c._write_loop()

  1101.         self.assertEqual(c.queue.task_done.call_count, 3)

  1102.         self.assertEqual(c.ws.send.call_count, 3)

  1103.         self.assertEqual(c.ws.send_binary.call_count, 0)

  1104.         self.assertEqual(c.ws.send.call_args_list[0][0][0], '4{"foo":"bar"}')

  1105.         self.assertEqual(c.ws.send.call_args_list[1][0][0], '2')

  1106.         self.assertEqual(c.ws.send.call_args_list[2][0][0], '6')

  1107. 

  1108.     def test_write_loop_websocket_one_packet_binary(self):

  1109.         c = client.Client()

  1110.         c.state = 'connected'

  1111.         c.ping_interval = 1

  1112.         c.ping_timeout = 2

  1113.         c.current_transport = 'websocket'

  1114.         c.queue = mock.MagicMock()

  1115.         c.queue.Empty = RuntimeError

  1116.         c.queue.get.side_effect = [

  1117.             packet.Packet(packet.MESSAGE, b'foo'),

  1118.             RuntimeError,

  1119.             RuntimeError

  1120.         ]

  1121.         c.ws = mock.MagicMock()

  1122.         c._write_loop()

  1123.         self.assertEqual(c.queue.task_done.call_count, 1)

  1124.         self.assertEqual(c.ws.send.call_count, 0)

  1125.         self.assertEqual(c.ws.send_binary.call_count, 1)

  1126.         c.ws.send_binary.assert_called_once_with(b'\x04foo')

  1127. 

  1128.     def test_write_loop_websocket_bad_connection(self):

  1129.         c = client.Client()

  1130.         c.state = 'connected'

  1131.         c.ping_interval = 1

  1132.         c.ping_timeout = 2

  1133.         c.current_transport = 'websocket'

  1134.         c.queue = mock.MagicMock()

  1135.         c.queue.Empty = RuntimeError

  1136.         c.queue.get.side_effect = [

  1137.             packet.Packet(packet.MESSAGE, {'foo': 'bar'}),

  1138.             RuntimeError,

  1139.             RuntimeError

  1140.         ]

  1141.         c.ws = mock.MagicMock()

  1142.         c.ws.send.side_effect = websocket.WebSocketConnectionClosedException

  1143.         c._write_loop()

  1144.         self.assertEqual(c.state, 'connected')

  1145. 

  1146.     @mock.patch('engineio.client.original_signal_handler')

  1147.     def test_signal_handler(self, original_handler):

  1148.         clients = [mock.MagicMock(), mock.MagicMock()]

  1149.         client.connected_clients = clients[:]

  1150.         client.connected_clients[0].is_asyncio_based.return_value = False

  1151.         client.connected_clients[1].is_asyncio_based.return_value = True

  1152.         client.signal_handler('sig', 'frame')

  1153.         clients[0].disconnect.assert_called_once_with(abort=True)

  1154.         clients[1].start_background_task.assert_called_once_with(

  1155.             clients[1].disconnect, abort=True)