Miguel Grinberg
2 years ago
committed by
GitHub
GitHub
30 changed files with 1208 additions and 73 deletions
@ -0,0 +1,15 @@ |
|||
Socket.IO Simple Client Examples |
|||
================================ |
|||
|
|||
This directory contains several example Socket.IO client applications built |
|||
with the simplified client and organized by directory: |
|||
|
|||
sync |
|||
---- |
|||
|
|||
Examples that use standard Python. |
|||
|
|||
async |
|||
----- |
|||
|
|||
Examples that use Python's `asyncio` package. |
|||
@ -0,0 +1,33 @@ |
|||
Socket.IO Async Simple Client Examples |
|||
====================================== |
|||
|
|||
This directory contains example Socket.IO clients that work with the |
|||
`asyncio` package of the Python standard library, built with the simplified |
|||
client. |
|||
|
|||
latency_client.py |
|||
----------------- |
|||
|
|||
In this application the client sends *ping* messages to the server, which are |
|||
responded by the server with a *pong*. The client measures the time it takes |
|||
for each of these exchanges. |
|||
|
|||
This is an ideal application to measure the performance of the different |
|||
asynchronous modes supported by the Socket.IO server. |
|||
|
|||
fiddle_client.py |
|||
---------------- |
|||
|
|||
This is an extemely simple application based on the JavaScript example of the |
|||
same name. |
|||
|
|||
Running the Examples |
|||
-------------------- |
|||
|
|||
These examples work with the server examples of the same name. First run one |
|||
of the ``latency.py`` or ``fiddle.py`` versions from one of the |
|||
``examples/server`` subdirectories. On another terminal, then start the |
|||
corresponding client:: |
|||
|
|||
$ python latency_client.py |
|||
$ python fiddle_client.py |
|||
@ -0,0 +1,13 @@ |
|||
import asyncio |
|||
import socketio |
|||
|
|||
|
|||
async def main(): |
|||
sio = socketio.AsyncSimpleClient() |
|||
await sio.connect('http://localhost:5000', auth={'token': 'my-token'}) |
|||
print(await sio.receive()) |
|||
await sio.disconnect() |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
asyncio.run(main()) |
|||
@ -0,0 +1,25 @@ |
|||
import asyncio |
|||
import time |
|||
import socketio |
|||
|
|||
|
|||
async def main(): |
|||
sio = socketio.AsyncSimpleClient() |
|||
await sio.connect('http://localhost:5000') |
|||
|
|||
try: |
|||
while True: |
|||
start_timer = time.time() |
|||
await sio.emit('ping_from_client') |
|||
while (await sio.receive()) != ['pong_from_server']: |
|||
pass |
|||
latency = time.time() - start_timer |
|||
print('latency is {0:.2f} ms'.format(latency * 1000)) |
|||
|
|||
await asyncio.sleep(1) |
|||
except (KeyboardInterrupt, asyncio.CancelledError): |
|||
await sio.disconnect() |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
asyncio.run(main()) |
|||
@ -0,0 +1,32 @@ |
|||
Socket.IO Simple Client Examples |
|||
================================ |
|||
|
|||
This directory contains example Socket.IO clients that are built using the |
|||
simplified client. |
|||
|
|||
latency_client.py |
|||
----------------- |
|||
|
|||
In this application the client sends *ping* messages to the server, which are |
|||
responded by the server with a *pong*. The client measures the time it takes |
|||
for each of these exchanges. |
|||
|
|||
This is an ideal application to measure the performance of the different |
|||
asynchronous modes supported by the Socket.IO server. |
|||
|
|||
fiddle_client.py |
|||
---------------- |
|||
|
|||
This is an extemely simple application based on the JavaScript example of the |
|||
same name. |
|||
|
|||
Running the Examples |
|||
-------------------- |
|||
|
|||
These examples work with the server examples of the same name. First run one |
|||
of the ``latency.py`` or ``fiddle.py`` versions from one of the |
|||
``examples/server`` subdirectories. On another terminal, then start the |
|||
corresponding client:: |
|||
|
|||
$ python latency_client.py |
|||
$ python fiddle_client.py |
|||
@ -0,0 +1,12 @@ |
|||
import socketio |
|||
|
|||
|
|||
def main(): |
|||
sio = socketio.SimpleClient() |
|||
sio.connect('http://localhost:5000', auth={'token': 'my-token'}) |
|||
print(sio.receive()) |
|||
sio.disconnect() |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
main() |
|||
@ -0,0 +1,24 @@ |
|||
import time |
|||
import socketio |
|||
|
|||
|
|||
def main(): |
|||
sio = socketio.SimpleClient() |
|||
sio.connect('http://localhost:5000') |
|||
|
|||
try: |
|||
while True: |
|||
start_timer = time.time() |
|||
sio.emit('ping_from_client') |
|||
while sio.receive() != ['pong_from_server']: |
|||
pass |
|||
latency = time.time() - start_timer |
|||
print('latency is {0:.2f} ms'.format(latency * 1000)) |
|||
|
|||
time.sleep(1) |
|||
except KeyboardInterrupt: |
|||
sio.disconnect() |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
main() |
|||
@ -0,0 +1,193 @@ |
|||
import asyncio |
|||
from socketio import AsyncClient |
|||
from socketio.exceptions import SocketIOError, TimeoutError, DisconnectedError |
|||
|
|||
|
|||
class AsyncSimpleClient: |
|||
"""A Socket.IO client. |
|||
|
|||
This class implements a simple, yet fully compliant Socket.IO web client |
|||
with support for websocket and long-polling transports. |
|||
|
|||
Th positional and keyword arguments given in the constructor are passed |
|||
to the underlying :func:`socketio.AsyncClient` object. |
|||
""" |
|||
def __init__(self, *args, **kwargs): |
|||
self.client_args = args |
|||
self.client_kwargs = kwargs |
|||
self.client = None |
|||
self.namespace = '/' |
|||
self.connected_event = asyncio.Event() |
|||
self.connected = False |
|||
self.input_event = asyncio.Event() |
|||
self.input_buffer = [] |
|||
|
|||
async def connect(self, url, headers={}, auth=None, transports=None, |
|||
namespace='/', socketio_path='socket.io'): |
|||
"""Connect to a Socket.IO server. |
|||
|
|||
:param url: The URL of the Socket.IO server. It can include custom |
|||
query string parameters if required by the server. If a |
|||
function is provided, the client will invoke it to obtain |
|||
the URL each time a connection or reconnection is |
|||
attempted. |
|||
:param headers: A dictionary with custom headers to send with the |
|||
connection request. If a function is provided, the |
|||
client will invoke it to obtain the headers dictionary |
|||
each time a connection or reconnection is attempted. |
|||
:param auth: Authentication data passed to the server with the |
|||
connection request, normally a dictionary with one or |
|||
more string key/value pairs. If a function is provided, |
|||
the client will invoke it to obtain the authentication |
|||
data each time a connection or reconnection is attempted. |
|||
:param transports: The list of allowed transports. Valid transports |
|||
are ``'polling'`` and ``'websocket'``. If not |
|||
given, the polling transport is connected first, |
|||
then an upgrade to websocket is attempted. |
|||
:param namespace: The namespace to connect to as a string. If not |
|||
given, the default namespace ``/`` is used. |
|||
:param socketio_path: The endpoint where the Socket.IO server is |
|||
installed. The default value is appropriate for |
|||
most cases. |
|||
|
|||
Note: this method is a coroutine. |
|||
""" |
|||
if self.connected: |
|||
raise RuntimeError('Already connected') |
|||
self.namespace = namespace |
|||
self.input_buffer = [] |
|||
self.input_event.clear() |
|||
self.client = AsyncClient(*self.client_args, **self.client_kwargs) |
|||
|
|||
@self.client.event |
|||
def connect(): # pragma: no cover |
|||
self.connected = True |
|||
self.connected_event.set() |
|||
|
|||
@self.client.event |
|||
def disconnect(): # pragma: no cover |
|||
self.connected_event.clear() |
|||
|
|||
@self.client.event |
|||
def __disconnect_final(): # pragma: no cover |
|||
self.connected = False |
|||
self.connected_event.set() |
|||
|
|||
@self.client.on('*') |
|||
def on_event(event, *args): # pragma: no cover |
|||
self.input_buffer.append([event, *args]) |
|||
self.input_event.set() |
|||
|
|||
await self.client.connect( |
|||
url, headers=headers, auth=auth, transports=transports, |
|||
namespaces=[namespace], socketio_path=socketio_path) |
|||
|
|||
@property |
|||
def sid(self): |
|||
"""The session ID received from the server. |
|||
|
|||
The session ID is not guaranteed to remain constant throughout the life |
|||
of the connection, as reconnections can cause it to change. |
|||
""" |
|||
return self.client.sid if self.client else None |
|||
|
|||
@property |
|||
def transport(self): |
|||
"""The name of the transport currently in use. |
|||
|
|||
The transport is returned as a string and can be one of ``polling`` |
|||
and ``websocket``. |
|||
""" |
|||
return self.client.transport if self.client else '' |
|||
|
|||
async def emit(self, event, data=None): |
|||
"""Emit an event to the server. |
|||
|
|||
:param event: The event name. It can be any string. The event names |
|||
``'connect'``, ``'message'`` and ``'disconnect'`` are |
|||
reserved and should not be used. |
|||
:param data: The data to send to the server. Data can be of |
|||
type ``str``, ``bytes``, ``list`` or ``dict``. To send |
|||
multiple arguments, use a tuple where each element is of |
|||
one of the types indicated above. |
|||
|
|||
Note: this method is a coroutine. |
|||
|
|||
This method schedules the event to be sent out and returns, without |
|||
actually waiting for its delivery. In cases where the client needs to |
|||
ensure that the event was received, :func:`socketio.SimpleClient.call` |
|||
should be used instead. |
|||
""" |
|||
while True: |
|||
await self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
try: |
|||
return await self.client.emit(event, data, |
|||
namespace=self.namespace) |
|||
except SocketIOError: |
|||
pass |
|||
|
|||
async def call(self, event, data=None, timeout=60): |
|||
"""Emit an event to the server and wait for a response. |
|||
|
|||
This method issues an emit and waits for the server to provide a |
|||
response or acknowledgement. If the response does not arrive before the |
|||
timeout, then a ``TimeoutError`` exception is raised. |
|||
|
|||
:param event: The event name. It can be any string. The event names |
|||
``'connect'``, ``'message'`` and ``'disconnect'`` are |
|||
reserved and should not be used. |
|||
:param data: The data to send to the server. Data can be of |
|||
type ``str``, ``bytes``, ``list`` or ``dict``. To send |
|||
multiple arguments, use a tuple where each element is of |
|||
one of the types indicated above. |
|||
:param timeout: The waiting timeout. If the timeout is reached before |
|||
the server acknowledges the event, then a |
|||
``TimeoutError`` exception is raised. |
|||
|
|||
Note: this method is a coroutine. |
|||
""" |
|||
while True: |
|||
await self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
try: |
|||
return await self.client.call(event, data, |
|||
namespace=self.namespace, |
|||
timeout=timeout) |
|||
except SocketIOError: |
|||
pass |
|||
|
|||
async def receive(self, timeout=None): |
|||
"""Wait for an event from the server. |
|||
|
|||
:param timeout: The waiting timeout. If the timeout is reached before |
|||
the server acknowledges the event, then a |
|||
``TimeoutError`` exception is raised. |
|||
|
|||
Note: this method is a coroutine. |
|||
|
|||
The return value is a list with the event name as the first element. If |
|||
the server included arguments with the event, they are returned as |
|||
additional list elements. |
|||
""" |
|||
if not self.input_buffer: |
|||
await self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
try: |
|||
await asyncio.wait_for(self.input_event.wait(), |
|||
timeout=timeout) |
|||
except asyncio.TimeoutError: |
|||
raise TimeoutError() |
|||
self.input_event.clear() |
|||
return self.input_buffer.pop(0) |
|||
|
|||
async def disconnect(self): |
|||
"""Disconnect from the server. |
|||
|
|||
Note: this method is a coroutine. |
|||
i """ |
|||
await self.client.disconnect() |
|||
self.client = None |
|||
@ -0,0 +1,177 @@ |
|||
from threading import Event |
|||
from socketio import Client |
|||
from socketio.exceptions import SocketIOError, TimeoutError, DisconnectedError |
|||
|
|||
|
|||
class SimpleClient: |
|||
"""A Socket.IO client. |
|||
|
|||
This class implements a simple, yet fully compliant Socket.IO web client |
|||
with support for websocket and long-polling transports. |
|||
|
|||
Th positional and keyword arguments given in the constructor are passed |
|||
to the underlying :func:`socketio.Client` object. |
|||
""" |
|||
def __init__(self, *args, **kwargs): |
|||
self.client_args = args |
|||
self.client_kwargs = kwargs |
|||
self.client = None |
|||
self.namespace = '/' |
|||
self.connected_event = Event() |
|||
self.connected = False |
|||
self.input_event = Event() |
|||
self.input_buffer = [] |
|||
|
|||
def connect(self, url, headers={}, auth=None, transports=None, |
|||
namespace='/', socketio_path='socket.io'): |
|||
"""Connect to a Socket.IO server. |
|||
|
|||
:param url: The URL of the Socket.IO server. It can include custom |
|||
query string parameters if required by the server. If a |
|||
function is provided, the client will invoke it to obtain |
|||
the URL each time a connection or reconnection is |
|||
attempted. |
|||
:param headers: A dictionary with custom headers to send with the |
|||
connection request. If a function is provided, the |
|||
client will invoke it to obtain the headers dictionary |
|||
each time a connection or reconnection is attempted. |
|||
:param auth: Authentication data passed to the server with the |
|||
connection request, normally a dictionary with one or |
|||
more string key/value pairs. If a function is provided, |
|||
the client will invoke it to obtain the authentication |
|||
data each time a connection or reconnection is attempted. |
|||
:param transports: The list of allowed transports. Valid transports |
|||
are ``'polling'`` and ``'websocket'``. If not |
|||
given, the polling transport is connected first, |
|||
then an upgrade to websocket is attempted. |
|||
:param namespace: The namespace to connect to as a string. If not |
|||
given, the default namespace ``/`` is used. |
|||
:param socketio_path: The endpoint where the Socket.IO server is |
|||
installed. The default value is appropriate for |
|||
most cases. |
|||
""" |
|||
if self.connected: |
|||
raise RuntimeError('Already connected') |
|||
self.namespace = namespace |
|||
self.input_buffer = [] |
|||
self.input_event.clear() |
|||
self.client = Client(*self.client_args, **self.client_kwargs) |
|||
|
|||
@self.client.event |
|||
def connect(): # pragma: no cover |
|||
self.connected = True |
|||
self.connected_event.set() |
|||
|
|||
@self.client.event |
|||
def disconnect(): # pragma: no cover |
|||
self.connected_event.clear() |
|||
|
|||
@self.client.event |
|||
def __disconnect_final(): # pragma: no cover |
|||
self.connected = False |
|||
self.connected_event.set() |
|||
|
|||
@self.client.on('*') |
|||
def on_event(event, *args): # pragma: no cover |
|||
self.input_buffer.append([event, *args]) |
|||
self.input_event.set() |
|||
|
|||
self.client.connect(url, headers=headers, auth=auth, |
|||
transports=transports, namespaces=[namespace], |
|||
socketio_path=socketio_path) |
|||
|
|||
@property |
|||
def sid(self): |
|||
"""The session ID received from the server. |
|||
|
|||
The session ID is not guaranteed to remain constant throughout the life |
|||
of the connection, as reconnections can cause it to change. |
|||
""" |
|||
return self.client.sid if self.client else None |
|||
|
|||
@property |
|||
def transport(self): |
|||
"""The name of the transport currently in use. |
|||
|
|||
The transport is returned as a string and can be one of ``polling`` |
|||
and ``websocket``. |
|||
""" |
|||
return self.client.transport if self.client else '' |
|||
|
|||
def emit(self, event, data=None): |
|||
"""Emit an event to the server. |
|||
|
|||
:param event: The event name. It can be any string. The event names |
|||
``'connect'``, ``'message'`` and ``'disconnect'`` are |
|||
reserved and should not be used. |
|||
:param data: The data to send to the server. Data can be of |
|||
type ``str``, ``bytes``, ``list`` or ``dict``. To send |
|||
multiple arguments, use a tuple where each element is of |
|||
one of the types indicated above. |
|||
|
|||
This method schedules the event to be sent out and returns, without |
|||
actually waiting for its delivery. In cases where the client needs to |
|||
ensure that the event was received, :func:`socketio.SimpleClient.call` |
|||
should be used instead. |
|||
""" |
|||
while True: |
|||
self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
try: |
|||
return self.client.emit(event, data, namespace=self.namespace) |
|||
except SocketIOError: |
|||
pass |
|||
|
|||
def call(self, event, data=None, timeout=60): |
|||
"""Emit an event to the server and wait for a response. |
|||
|
|||
This method issues an emit and waits for the server to provide a |
|||
response or acknowledgement. If the response does not arrive before the |
|||
timeout, then a ``TimeoutError`` exception is raised. |
|||
|
|||
:param event: The event name. It can be any string. The event names |
|||
``'connect'``, ``'message'`` and ``'disconnect'`` are |
|||
reserved and should not be used. |
|||
:param data: The data to send to the server. Data can be of |
|||
type ``str``, ``bytes``, ``list`` or ``dict``. To send |
|||
multiple arguments, use a tuple where each element is of |
|||
one of the types indicated above. |
|||
:param timeout: The waiting timeout. If the timeout is reached before |
|||
the server acknowledges the event, then a |
|||
``TimeoutError`` exception is raised. |
|||
""" |
|||
while True: |
|||
self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
try: |
|||
return self.client.call(event, data, namespace=self.namespace, |
|||
timeout=timeout) |
|||
except SocketIOError: |
|||
pass |
|||
|
|||
def receive(self, timeout=None): |
|||
"""Wait for an event from the server. |
|||
|
|||
:param timeout: The waiting timeout. If the timeout is reached before |
|||
the server acknowledges the event, then a |
|||
``TimeoutError`` exception is raised. |
|||
|
|||
The return value is a list with the event name as the first element. If |
|||
the server included arguments with the event, they are returned as |
|||
additional list elements. |
|||
""" |
|||
if not self.input_buffer: |
|||
self.connected_event.wait() |
|||
if not self.connected: |
|||
raise DisconnectedError() |
|||
if not self.input_event.wait(timeout=timeout): |
|||
raise TimeoutError() |
|||
self.input_event.clear() |
|||
return self.input_buffer.pop(0) |
|||
|
|||
def disconnect(self): |
|||
"""Disconnect from the server.""" |
|||
self.client.disconnect() |
|||
self.client = None |
|||
@ -0,0 +1,163 @@ |
|||
import asyncio |
|||
import unittest |
|||
from unittest import mock |
|||
import pytest |
|||
from socketio import AsyncSimpleClient |
|||
from socketio.exceptions import SocketIOError, TimeoutError, DisconnectedError |
|||
from .helpers import AsyncMock, _run |
|||
|
|||
|
|||
class TestAsyncAsyncSimpleClient(unittest.TestCase): |
|||
def test_constructor(self): |
|||
client = AsyncSimpleClient(1, '2', a='3', b=4) |
|||
assert client.client_args == (1, '2') |
|||
assert client.client_kwargs == {'a': '3', 'b': 4} |
|||
assert client.client is None |
|||
assert client.input_buffer == [] |
|||
assert not client.connected |
|||
|
|||
def test_connect(self): |
|||
client = AsyncSimpleClient(123, a='b') |
|||
with mock.patch('socketio.asyncio_simple_client.AsyncClient') \ |
|||
as mock_client: |
|||
mock_client.return_value.connect = AsyncMock() |
|||
|
|||
_run(client.connect('url', headers='h', auth='a', transports='t', |
|||
namespace='n', socketio_path='s')) |
|||
mock_client.assert_called_once_with(123, a='b') |
|||
assert client.client == mock_client() |
|||
mock_client().connect.mock.assert_called_once_with( |
|||
'url', headers='h', auth='a', transports='t', |
|||
namespaces=['n'], socketio_path='s') |
|||
mock_client().event.call_count == 3 |
|||
mock_client().on.called_once_with('*') |
|||
assert client.namespace == 'n' |
|||
assert not client.input_event.is_set() |
|||
|
|||
def test_connect_twice(self): |
|||
client = AsyncSimpleClient(123, a='b') |
|||
client.client = mock.MagicMock() |
|||
client.connected = True |
|||
|
|||
with pytest.raises(RuntimeError): |
|||
_run(client.connect('url')) |
|||
|
|||
def test_properties(self): |
|||
client = AsyncSimpleClient() |
|||
client.client = mock.MagicMock(sid='sid', transport='websocket') |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
assert client.sid == 'sid' |
|||
assert client.transport == 'websocket' |
|||
|
|||
def test_emit(self): |
|||
client = AsyncSimpleClient() |
|||
client.client = mock.MagicMock() |
|||
client.client.emit = AsyncMock() |
|||
client.namespace = '/ns' |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
_run(client.emit('foo', 'bar')) |
|||
assert client.client.emit.mock.called_once_with('foo', 'bar', |
|||
namespace='/ns') |
|||
|
|||
def test_emit_disconnected(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
_run(client.emit('foo', 'bar')) |
|||
|
|||
def test_emit_retries(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.client = mock.MagicMock() |
|||
client.client.emit = AsyncMock() |
|||
client.client.emit.mock.side_effect = [SocketIOError(), None] |
|||
|
|||
_run(client.emit('foo', 'bar')) |
|||
client.client.emit.mock.assert_called_with('foo', 'bar', namespace='/') |
|||
|
|||
def test_call(self): |
|||
client = AsyncSimpleClient() |
|||
client.client = mock.MagicMock() |
|||
client.client.call = AsyncMock() |
|||
client.client.call.mock.return_value = 'result' |
|||
client.namespace = '/ns' |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
assert _run(client.call('foo', 'bar')) == 'result' |
|||
assert client.client.call.mock.called_once_with('foo', 'bar', |
|||
namespace='/ns', |
|||
timeout=60) |
|||
|
|||
def test_call_disconnected(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
_run(client.call('foo', 'bar')) |
|||
|
|||
def test_call_retries(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.client = mock.MagicMock() |
|||
client.client.call = AsyncMock() |
|||
client.client.call.mock.side_effect = [SocketIOError(), 'result'] |
|||
|
|||
assert _run(client.call('foo', 'bar')) == 'result' |
|||
client.client.call.mock.assert_called_with('foo', 'bar', namespace='/', |
|||
timeout=60) |
|||
|
|||
def test_receive_with_input_buffer(self): |
|||
client = AsyncSimpleClient() |
|||
client.input_buffer = ['foo', 'bar'] |
|||
assert _run(client.receive()) == 'foo' |
|||
assert _run(client.receive()) == 'bar' |
|||
|
|||
def test_receive_without_input_buffer(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.input_event = mock.MagicMock() |
|||
|
|||
async def fake_wait(timeout=None): |
|||
client.input_buffer = ['foo'] |
|||
return True |
|||
|
|||
client.input_event.wait = fake_wait |
|||
assert _run(client.receive()) == 'foo' |
|||
|
|||
def test_receive_with_timeout(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.input_event = mock.MagicMock() |
|||
|
|||
async def fake_wait(timeout=None): |
|||
await asyncio.sleep(1) |
|||
|
|||
client.input_event.wait = fake_wait |
|||
with pytest.raises(TimeoutError): |
|||
_run(client.receive(timeout=0.01)) |
|||
|
|||
def test_receive_disconnected(self): |
|||
client = AsyncSimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
_run(client.receive()) |
|||
|
|||
def test_disconnect(self): |
|||
client = AsyncSimpleClient() |
|||
mc = mock.MagicMock() |
|||
mc.disconnect = AsyncMock() |
|||
client.client = mc |
|||
_run(client.disconnect()) |
|||
mc.disconnect.mock.assert_called_once_with() |
|||
assert client.client is None |
|||
@ -0,0 +1,146 @@ |
|||
import unittest |
|||
from unittest import mock |
|||
import pytest |
|||
from socketio import SimpleClient |
|||
from socketio.exceptions import SocketIOError, TimeoutError, DisconnectedError |
|||
|
|||
|
|||
class TestSimpleClient(unittest.TestCase): |
|||
def test_constructor(self): |
|||
client = SimpleClient(1, '2', a='3', b=4) |
|||
assert client.client_args == (1, '2') |
|||
assert client.client_kwargs == {'a': '3', 'b': 4} |
|||
assert client.client is None |
|||
assert client.input_buffer == [] |
|||
assert not client.connected |
|||
|
|||
def test_connect(self): |
|||
client = SimpleClient(123, a='b') |
|||
with mock.patch('socketio.simple_client.Client') as mock_client: |
|||
client.connect('url', headers='h', auth='a', transports='t', |
|||
namespace='n', socketio_path='s') |
|||
mock_client.assert_called_once_with(123, a='b') |
|||
assert client.client == mock_client() |
|||
mock_client().connect.assert_called_once_with( |
|||
'url', headers='h', auth='a', transports='t', |
|||
namespaces=['n'], socketio_path='s') |
|||
mock_client().event.call_count == 3 |
|||
mock_client().on.called_once_with('*') |
|||
assert client.namespace == 'n' |
|||
assert not client.input_event.is_set() |
|||
|
|||
def test_connect_twice(self): |
|||
client = SimpleClient(123, a='b') |
|||
client.client = mock.MagicMock() |
|||
client.connected = True |
|||
|
|||
with pytest.raises(RuntimeError): |
|||
client.connect('url') |
|||
|
|||
def test_properties(self): |
|||
client = SimpleClient() |
|||
client.client = mock.MagicMock(sid='sid', transport='websocket') |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
assert client.sid == 'sid' |
|||
assert client.transport == 'websocket' |
|||
|
|||
def test_emit(self): |
|||
client = SimpleClient() |
|||
client.client = mock.MagicMock() |
|||
client.namespace = '/ns' |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
client.emit('foo', 'bar') |
|||
assert client.client.emit.called_once_with('foo', 'bar', |
|||
namespace='/ns') |
|||
|
|||
def test_emit_disconnected(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
client.emit('foo', 'bar') |
|||
|
|||
def test_emit_retries(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.client = mock.MagicMock() |
|||
client.client.emit.side_effect = [SocketIOError(), None] |
|||
|
|||
client.emit('foo', 'bar') |
|||
client.client.emit.assert_called_with('foo', 'bar', namespace='/') |
|||
|
|||
def test_call(self): |
|||
client = SimpleClient() |
|||
client.client = mock.MagicMock() |
|||
client.client.call.return_value = 'result' |
|||
client.namespace = '/ns' |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
|
|||
assert client.call('foo', 'bar') == 'result' |
|||
client.client.call.called_once_with('foo', 'bar', namespace='/ns', |
|||
timeout=60) |
|||
|
|||
def test_call_disconnected(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
client.call('foo', 'bar') |
|||
|
|||
def test_call_retries(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.client = mock.MagicMock() |
|||
client.client.call.side_effect = [SocketIOError(), 'result'] |
|||
|
|||
assert client.call('foo', 'bar') == 'result' |
|||
client.client.call.assert_called_with('foo', 'bar', namespace='/', |
|||
timeout=60) |
|||
|
|||
def test_receive_with_input_buffer(self): |
|||
client = SimpleClient() |
|||
client.input_buffer = ['foo', 'bar'] |
|||
assert client.receive() == 'foo' |
|||
assert client.receive() == 'bar' |
|||
|
|||
def test_receive_without_input_buffer(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
client.input_event = mock.MagicMock() |
|||
|
|||
def fake_wait(timeout=None): |
|||
client.input_buffer = ['foo'] |
|||
return True |
|||
|
|||
client.input_event.wait = fake_wait |
|||
assert client.receive() == 'foo' |
|||
|
|||
def test_receive_with_timeout(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = True |
|||
with pytest.raises(TimeoutError): |
|||
client.receive(timeout=0.01) |
|||
|
|||
def test_receive_disconnected(self): |
|||
client = SimpleClient() |
|||
client.connected_event.set() |
|||
client.connected = False |
|||
with pytest.raises(DisconnectedError): |
|||
client.receive() |
|||
|
|||
def test_disconnect(self): |
|||
client = SimpleClient() |
|||
mc = mock.MagicMock() |
|||
client.client = mc |
|||
client.disconnect() |
|||
mc.disconnect.assert_called_once_with() |
|||
assert client.client is None |
|||
Loading…
Reference in new issue