async def test_multiple_clients(create_event_server, client_count):
backend_conf = {'module': 'hat.event.server.backends.dummy'}
modules_conf = []
with create_event_server(backend_conf, modules_conf) as srv:
srv.wait_active(5)
clients = []
for _ in range(client_count):
client = await hat.event.client.connect(srv.address, [('a', )])
clients.append(client)
for i, sender in enumerate(clients):
client.register([
common.RegisterEvent(
('a', ), None,
common.EventPayload(type=common.EventPayloadType.JSON,
data=i))
])
for receiver in clients:
evts = await asyncio.wait_for(receiver.receive(), 1)
assert evts[0].payload.data == i
for client in clients:
await client.async_close()
async def test_event_receive(event_client_factory, adapter_factory):
client = await event_client_factory([['*']])
adapters_conf = [{'name': 'adapter1',
'module': 'test_unit.test_gui.mock'}]
async with adapter_factory(adapters_conf) as adapters:
adapter = adapters['adapter1']
assert adapter.conf == adapters_conf[0]
client.register([
hat.event.common.RegisterEvent(
event_type=['hat', 'gui', 'mock', 'system'],
source_timestamp=hat.event.common.now(),
payload=hat.event.common.EventPayload(
hat.event.common.EventPayloadType.JSON,
data={'abc': 'def'})),
hat.event.common.RegisterEvent(
event_type=['hat', 'gui', 'mock'],
source_timestamp=None,
payload=hat.event.common.EventPayload(
hat.event.common.EventPayloadType.JSON,
data={'abc': 'def'})),
hat.event.common.RegisterEvent(
event_type=['should', 'not', 'receive'],
source_timestamp=None,
payload=hat.event.common.EventPayload(
hat.event.common.EventPayloadType.JSON,
data={'abc': 'def'}))])
events = await client.receive()
filtered = [ev for ev in events
if ev.event_type != ['should', 'not', 'receive']]
adapter_events = await adapter.client.receive()
assert filtered == adapter_events
async def test_register(create_event_server):
backend_conf = {'module': 'hat.event.server.backends.dummy'}
modules_conf = []
register_event = common.RegisterEvent(
event_type=('a', ),
source_timestamp=common.now(),
payload=common.EventPayload(type=common.EventPayloadType.BINARY,
data=b'123'))
with create_event_server(backend_conf, modules_conf) as srv:
srv.wait_active(5)
client = await hat.event.client.connect(srv.address)
client.register([register_event])
resp = await client.register_with_response([register_event])
assert len(resp) == 1
assert resp[0].event_type == register_event.event_type
assert resp[0].source_timestamp == register_event.source_timestamp
assert resp[0].payload == register_event.payload
assert not client.is_closed
await client.async_close()
async def test_create_session(create_event_server, remote_msgs,
mock_module_conf):
backend_conf = {'module': 'hat.event.server.backends.dummy'}
modules_conf = [mock_module_conf]
with create_event_server(backend_conf, modules_conf) as srv:
msg = await asyncio.wait_for(remote_msgs.get(), 1)
assert msg == 'ModuleCreate'
srv.wait_active(1)
client = await hat.event.client.connect(srv.address)
client.register([hat.event.common.RegisterEvent(['a'], None, None)])
msg = await asyncio.wait_for(remote_msgs.get(), 1)
assert msg == 'SessionCreate'
msg = await asyncio.wait_for(remote_msgs.get(), 1)
assert msg == 'Process'
msg = await asyncio.wait_for(remote_msgs.get(), 1)
assert msg == 'SessionClose'
await client.async_close()
msg = await asyncio.wait_for(remote_msgs.get(), 1)
assert msg == 'ModuleClose'
async def test_register(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.register(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]
subscription_events = await client.receive()
assert events == subscription_events
await client.async_close()
await comm.async_close()
await engine.async_close()
async def test_register(comm_address, comm_conf):
register_events = [
hat.event.common.RegisterEvent(event_type=('test', 'a'),
source_timestamp=None,
payload=None),
hat.event.common.RegisterEvent(
event_type=('test', 'a'),
source_timestamp=hat.event.common.Timestamp(s=0, us=0),
payload=hat.event.common.EventPayload(
type=hat.event.common.EventPayloadType.JSON,
data={
'a': True,
'b': [0, 1, None, 'c']
})),
hat.event.common.RegisterEvent(
event_type=('test', 'b'),
source_timestamp=None,
payload=hat.event.common.EventPayload(
type=hat.event.common.EventPayloadType.BINARY, data=b'Test')),
hat.event.common.RegisterEvent(
event_type=('test', ),
source_timestamp=None,
payload=hat.event.common.EventPayload(
type=hat.event.common.EventPayloadType.SBS,
data=hat.event.common.SbsData(module=None,
type='Bytes',
data=b'Test')))
]
register_queue = aio.Queue()
def register_cb(source, events):
register_queue.put_nowait(events)
return [None for event in events]
engine = ModuleEngine(register_cb=register_cb)
comm = await hat.event.server.communication.create(comm_conf, engine)
client = await hat.event.client.connect(comm_address)
events = await register_queue.get()
assert len(events) == 1
assert events[0].event_type == ('event', 'communication', 'connected')
client.register(register_events)
events = await register_queue.get()
assert events == register_events
await client.async_close()
events = await register_queue.get()
assert len(events) == 1
assert events[0].event_type == ('event', 'communication', 'disconnected')
await comm.async_close()
await engine.async_close()
async def run_cb(client):
client.register([
common.RegisterEvent(event_type=('a', ),
source_timestamp=common.now(),
payload=None)
])
try:
await asyncio.Future()
finally:
await client.register_with_response([
common.RegisterEvent(event_type=('b'),
source_timestamp=common.now(),
payload=None)
])
client.register([
common.RegisterEvent(event_type=('c'),
source_timestamp=common.now(),
payload=None)
])
async def test_client_register(server_address):
register_events = [
common.RegisterEvent(event_type=('a', 'b', 'c'),
source_timestamp=common.now(),
payload=common.EventPayload(
common.EventPayloadType.JSON, i))
for i in range(10)
]
server = await create_server(server_address)
client = await hat.event.client.connect(server_address)
conn = await server.get_connection()
client.register([])
msg = await conn.receive()
assert msg.first is True
assert msg.last is True
assert msg.data == chatter.Data('HatEvent', 'MsgRegisterReq', [])
client.register(register_events)
msg = await conn.receive()
assert msg.first is True
assert msg.last is True
assert msg.data == chatter.Data(
'HatEvent', 'MsgRegisterReq',
[common.register_event_to_sbs(i) for i in register_events])
await conn.async_close()
await client.async_close()
await server.async_close()
with pytest.raises(ConnectionError):
client.register(register_events)
async def test_subscribe(create_event_server):
backend_conf = {'module': 'hat.event.server.backends.dummy'}
modules_conf = []
with create_event_server(backend_conf, modules_conf) as srv:
srv.wait_active(5)
client = await hat.event.client.connect(srv.address, [('a', '*')])
client.register([common.RegisterEvent(('a', ), None, None)])
evts = await asyncio.wait_for(client.receive(), 0.1)
assert evts[0].event_type == ('a', )
client.register([common.RegisterEvent(('b', ), None, None)])
with pytest.raises(asyncio.TimeoutError):
await asyncio.wait_for(client.receive(), 0.1)
client.register([common.RegisterEvent(('a', 'b', 'c'), None, None)])
evts = await asyncio.wait_for(client.receive(), 0.1)
assert evts[0].event_type == ('a', 'b', 'c')
await client.async_close()
