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'),
