async def test_register_with_response(comm_conf, register_events):
def register_cb(events):
register_queue.put_nowait(events)
return [common.process_event_to_event(i) for i in events]
register_queue = aio.Queue()
engine = common.create_module_engine(register_cb=register_cb)
comm = await hat.event.server.communication.create(comm_conf, engine)
client = await hat.event.client.connect(comm_conf['address'],
subscriptions=['*'])
client_events = await client.register_with_response(register_events)
process_events = await register_queue.get()
assert all(
type(event) == hat.event.server.common.ProcessEvent
for event in process_events)
assert all(
common.compare_register_event_vs_event(r, p)
for r, p in zip(register_events, process_events))
events = [common.process_event_to_event(i) for i in process_events]
assert events == client_events
subscription_events = await client.receive()
assert events == subscription_events
await client.async_close()
await comm.async_close()
await engine.async_close()
async def test_query(comm_conf):
def query_cb(data):
query_queue.put_nowait(data)
return mock_result
mock_query = hat.event.common.QueryData()
mock_result = [
hat.event.common.Event(event_id=hat.event.common.EventId(server=0,
instance=0),
event_type=['mock'],
timestamp=hat.event.common.Timestamp(s=0, us=0),
source_timestamp=None,
payload=None)
]
query_queue = aio.Queue()
engine = common.create_module_engine(query_cb=query_cb)
comm = await hat.event.server.communication.create(comm_conf, engine)
client = await hat.event.client.connect(comm_conf['address'])
events = await client.query(mock_query)
query_data = await query_queue.get()
assert events == mock_result
assert query_data == mock_query
await client.async_close()
await comm.async_close()
await engine.async_close()
async def test_client_connect_disconnect(comm_conf):
with pytest.raises(Exception):
await hat.event.client.connect(comm_conf['address'])
engine = common.create_module_engine()
comm = await hat.event.server.communication.create(comm_conf, engine)
assert not comm.closed.done()
client = await hat.event.client.connect(comm_conf['address'])
assert not client.closed.done()
await client.async_close()
await comm.async_close()
await engine.async_close()
assert client.closed.done()
assert comm.closed.done()
with pytest.raises(Exception):
await hat.event.client.connect(comm_conf['address'])
async def test_subscribe(comm_conf, subscriptions):
event_types = [[], ['a'], ['b'], ['a', 'a'], ['a', 'b'], ['a', 'b', 'c'],
['', '', '']]
engine = common.create_module_engine()
comm = await hat.event.server.communication.create(comm_conf, engine)
client = await hat.event.client.connect(comm_conf['address'],
subscriptions=subscriptions)
await asyncio.sleep(0.01) # allow server to receive `Subscribe` message
engine._register_event_cbs.notify([
hat.event.common.Event(event_id=hat.event.common.EventId(server=0,
instance=i),
event_type=event_type,
timestamp=hat.event.common.Timestamp(s=0, us=0),
source_timestamp=None,
payload=None)
for i, event_type in enumerate(event_types)
])
filtered_event_types = [
event_type for event_type in event_types if any(
hat.event.common.matches_query_type(event_type, query_type)
for query_type in subscriptions)
]
if filtered_event_types:
events = await client.receive()
assert (set(
(tuple(i.event_type)
for i in events)) == set(tuple(i) for i in filtered_event_types))
await client.async_close()
await comm.async_close()
await engine.async_close()
async def test_srv_comm_close(comm_conf, register_events):
comm_register = asyncio.Event()
comm_query = asyncio.Event()
async def unresponsive_cb(async_event, _):
async_event.set()
while True:
await asyncio.sleep(1)
engine = common.create_module_engine(
register_cb=functools.partial(unresponsive_cb, comm_register),
query_cb=functools.partial(unresponsive_cb, comm_query))
comm = await hat.event.server.communication.create(comm_conf, engine)
assert not comm.closed.done()
client = await hat.event.client.connect(comm_conf['address'])
assert not client.closed.done()
async with aio.Group() as group:
futures = [
group.spawn(client.receive),
group.spawn(client.register_with_response, register_events),
group.spawn(client.query, hat.event.common.QueryData())
]
await asyncio.gather(comm_register.wait(), comm_query.wait())
await comm.async_close()
await engine.async_close()
assert comm.closed.done()
for f in futures:
with pytest.raises(hat.chatter.ConnectionClosedError):
await f
await client.closed