async def test_can_send_binary_data_over_connection(tcp_connection_class,
integration_tcp_server_and_pipe):
from moler.threaded_moler_connection import ThreadedMolerConnection
(tcp_server, tcp_server_pipe) = integration_tcp_server_and_pipe
moler_conn = ThreadedMolerConnection() # no decoder, just pass bytes 1:1
connection = tcp_connection_class(moler_connection=moler_conn, port=tcp_server.port, host=tcp_server.host)
async with connection:
moler_conn.send(data=b'data to be send') # TODO: await moler_conn.send(data=b'data to be send') ???
time.sleep(0.1) # otherwise we have race between server's pipe and from-client-connection
tcp_server_pipe.send(("get history", {}))
dialog_with_server = tcp_server_pipe.recv()
assert ['Received data:', b'data to be send'] == dialog_with_server[-1]
def test_can_work_with_multiple_connections(
tcp_connection_class, integration_tcp_server_and_pipe,
integration_second_tcp_server_and_pipe):
"""Check open/close/send/receive on multiple connections"""
from moler.threaded_moler_connection import ThreadedMolerConnection
(tcp_server0, tcp_server0_pipe) = integration_tcp_server_and_pipe
(tcp_server1, tcp_server1_pipe) = integration_second_tcp_server_and_pipe
received_data = [bytearray(), bytearray()]
receiver_called = [threading.Event(), threading.Event()]
def receiver0(data, time_recv):
received_data[0].extend(data)
receiver_called[0].set()
def receiver1(data, time_recv):
received_data[1].extend(data)
receiver_called[1].set()
def do_nothig_func():
pass
moler_conn0 = ThreadedMolerConnection()
moler_conn0.subscribe(receiver0, do_nothig_func)
moler_conn1 = ThreadedMolerConnection()
moler_conn1.subscribe(receiver1, do_nothig_func)
connection0 = tcp_connection_class(moler_connection=moler_conn0,
port=tcp_server0.port,
host=tcp_server0.host)
connection1 = tcp_connection_class(moler_connection=moler_conn1,
port=tcp_server1.port,
host=tcp_server1.host)
with connection0.open():
with connection1.open():
time.sleep(0.1) # to let servers notify connecting clients
tcp_server0_pipe.send(("send async msg", {
'msg': b'data from server 0'
}))
tcp_server1_pipe.send(("send async msg", {
'msg': b'data from server 1'
}))
assert receiver_called[0].wait(timeout=0.5)
assert receiver_called[1].wait(timeout=0.5)
moler_conn0.send(data=b'data to server 0')
moler_conn1.send(data=b'data to server 1')
time.sleep(0.1) # to let servers get what was sent
# what we got from servers
assert b'data from server 0' == received_data[0]
assert b'data from server 1' == received_data[1]
# what servers know about clients
tcp_server0_pipe.send(("get history", {}))
tcp_server1_pipe.send(("get history", {}))
dialog_with_server0 = tcp_server0_pipe.recv()
dialog_with_server1 = tcp_server1_pipe.recv()
assert 'Client connected' == dialog_with_server0[0]
assert 'Client connected' == dialog_with_server0[0]
assert ['Received data:', b'data to server 0'] == dialog_with_server0[-2]
assert ['Received data:', b'data to server 1'] == dialog_with_server1[-2]
assert 'Client disconnected' == dialog_with_server0[-1]
assert 'Client disconnected' == dialog_with_server1[-1]
