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()