async def test_subscribe(comm_address, comm_conf, subscriptions): subscription = common.Subscription(subscriptions) event_types = [[], ['a'], ['b'], ['a', 'a'], ['a', 'b'], ['a', 'b', 'c'], ['', '', '']] filtered_event_types = [ event_type for event_type in event_types if subscription.matches(event_type) ] events = [ hat.event.common.Event(event_id=hat.event.common.EventId(server=0, instance=i), event_type=event_type, timestamp=common.now(), source_timestamp=None, payload=None) for i, event_type in enumerate(event_types) ] engine = ModuleEngine() comm = await hat.event.server.communication.create(comm_conf, engine) client = await hat.event.client.connect(comm_address, subscriptions) await client.query(common.QueryData()) # process `Subscribe` message engine.notify(events) if filtered_event_types: events = await client.receive() assert ({tuple(i.event_type) for i in events} == {tuple(i) for i in filtered_event_types}) await client.async_close() await comm.async_close() await engine.async_close()
async def test_query(comm_address, comm_conf): event_types = [(), ('a', ), ('b', ), ('a', 'a'), ('a', 'b'), ('a', 'b', 'c'), ('', '', '')] events = [ hat.event.common.Event(event_id=hat.event.common.EventId(server=0, instance=i), event_type=event_type, timestamp=common.now(), source_timestamp=None, payload=None) for i, event_type in enumerate(event_types) ] query_data = common.QueryData() query_queue = aio.Queue() def query_cb(data): query_queue.put_nowait(data) return events engine = ModuleEngine(query_cb=query_cb) comm = await hat.event.server.communication.create(comm_conf, engine) client = await hat.event.client.connect(comm_address) result = await client.query(query_data) assert result == events temp_query_data = await query_queue.get() assert temp_query_data == query_data await client.async_close() await comm.async_close() await engine.async_close()
async def test_without_subscribe(comm_address, comm_conf): event_types = [(), ('a', ), ('b', ), ('a', 'a'), ('a', 'b'), ('a', 'b', 'c'), ('', '', '')] events = [ hat.event.common.Event(event_id=hat.event.common.EventId(server=0, instance=i), event_type=event_type, timestamp=common.now(), source_timestamp=None, payload=None) for i, event_type in enumerate(event_types) ] engine = ModuleEngine() comm = await hat.event.server.communication.create(comm_conf, engine) client = await hat.event.client.connect(comm_address) await client.query(common.QueryData()) engine.notify(events) with pytest.raises(asyncio.TimeoutError): await asyncio.wait_for(client.receive(), 0.01) await client.async_close() await comm.async_close() await engine.async_close()
async def test_create_process_event(): server_id = 123 source = common.Source(common.SourceType.MODULE, None, 321) register_events = [ common.RegisterEvent(event_type=(str(i), ), source_timestamp=common.now(), payload=None) for i in range(10) ] conf = {'modules': []} backend = BackendEngine(server_id=server_id) engine = await hat.event.server.module_engine.create(conf, backend) event_ids = set() for register_event in register_events: process_event = engine.create_process_event(source, register_event) assert process_event.event_type == register_event.event_type assert ( process_event.source_timestamp == register_event.source_timestamp) assert process_event.payload == register_event.payload assert process_event.source == source assert process_event.event_id.server == 123 assert process_event.event_id not in event_ids event_ids.add(process_event.event_id) await engine.async_close() await backend.async_close()
async def register(self, events): """Register events Args: events (List[common.ProcessEvent]): process events Returns: List[Optional[common.Event]] """ now = common.now() backend_events = [common.BackendEvent( event_id=event.event_id, event_type_id=self._get_event_type_id(event.event_type), timestamp=now, source_timestamp=event.source_timestamp, payload=event.payload ) for event in events] if self._new_mappings: await self._backend.add_event_type_id_mappings(self._new_mappings) self._new_mappings = {} await self._backend.register(backend_events) return [common.Event( event_id=event.event_id, event_type=event.event_type, timestamp=now, source_timestamp=event.source_timestamp, payload=event.payload ) for event in events]
def register_cb(source, events): register_queue.put_nowait(events) process_events = [ engine.create_process_event(source, event) for event in events ] return [ common.Event(event_id=i.event_id, event_type=i.event_type, timestamp=common.now(), source_timestamp=i.source_timestamp, payload=i.payload) for i in process_events ]
async def register(self, process_events): if not self._register_cb: now = common.now() return [ common.Event(event_id=process_event.event_id, event_type=process_event.event_type, timestamp=now, source_timestamp=process_event.source_timestamp, payload=process_event.payload) for process_event in process_events ] return self._register_cb(process_events)
def test_now(): previous_dt = None for _ in range(10): now_dt = common.timestamp_to_datetime(common.now()) delta = datetime.datetime.now(datetime.timezone.utc) - now_dt assert delta < datetime.timedelta(seconds=1) if previous_dt is not None: assert now_dt >= previous_dt previous_dt = now_dt
async def register( self, process_events: typing.List[common.ProcessEvent] ) -> typing.List[typing.Optional[common.Event]]: """Register events""" now = common.now() events = [ common.Event(event_id=process_event.event_id, event_type=process_event.event_type, timestamp=now, source_timestamp=process_event.source_timestamp, payload=process_event.payload) for process_event in process_events ] return await self._backend.register(events)
async def test_register(event_count): events = [ hat.event.common.Event(event_id=hat.event.common.EventId(server=0, instance=i), event_type=(), timestamp=common.now(), source_timestamp=None, payload=None) for i in range(event_count) ] conf = {'module': 'hat.event.server.backends.dummy'} backend = await hat.event.server.backends.dummy.create(conf) result = await backend.register(events) assert result == events await backend.async_close()
async def test_register(backend_module_name, create_backend_module): conf = {'server_id': 123, 'backend': {'module': backend_module_name}} event_ids = [common.EventId(conf['server_id'], i) for i in range(10)] process_events = [ common.ProcessEvent(event_id=event_id, source=common.Source(common.SourceType.MODULE, 'abc', 1), event_type=[], source_timestamp=common.now(), payload=None) for event_id in event_ids ] def register(events): return events with create_backend_module(register_cb=register): engine = await hat.event.server.backend_engine.create(conf) events = await engine.register(process_events) assert [i.event_id for i in events] == event_ids await engine.async_close()
async def test_query(backend_module_name, create_backend_module): conf = {'server_id': 123, 'backend': {'module': backend_module_name}} event_ids = [common.EventId(conf['server_id'], i) for i in range(10)] events = [ common.Event(event_id=event_id, event_type=[], timestamp=common.now(), source_timestamp=None, payload=None) for event_id in event_ids ] query_data = common.QueryData() def query(data): assert query_data == data return events with create_backend_module(query_cb=query): engine = await hat.event.server.backend_engine.create(conf) result = await engine.query(query_data) assert result == events await engine.async_close()
async def test_query(): query_data = common.QueryData() events = [ common.Event(event_id=common.EventId(1, i), event_type=(), timestamp=common.now(), source_timestamp=None, payload=None) for i in range(10) ] def on_query(data): assert data == query_data return events conf = {'modules': []} backend = BackendEngine(query_cb=on_query) engine = await hat.event.server.module_engine.create(conf, backend) result = await engine.query(query_data) assert result == events await engine.async_close() await backend.async_close()
for _ in range(10): now_dt = common.timestamp_to_datetime(common.now()) delta = datetime.datetime.now(datetime.timezone.utc) - now_dt assert delta < datetime.timedelta(seconds=1) if previous_dt is not None: assert now_dt >= previous_dt previous_dt = now_dt @pytest.mark.parametrize("event", [ common.Event( event_id=common.EventId(0, 0), event_type=('a',), timestamp=common.now(), source_timestamp=None, payload=None), common.Event( event_id=common.EventId(0, 0), event_type=('a',), timestamp=common.now(), source_timestamp=common.now(), payload=common.EventPayload( type=common.EventPayloadType.BINARY, data=b'123')), common.Event( event_id=common.EventId(123, 456), event_type=('a', 'b', 'c'),