async def test_change(executor, env, flush):
name = 'name'
server_id = 123
db = await hat.event.server.backends.lmdb.systemdb.create(
executor=executor, env=env, name=name, server_id=server_id)
await flush(db)
assert db.data == common.SystemData(server_id=server_id,
last_instance_id=None,
last_timestamp=None)
t = common.now()
db.change(123, t)
assert db.data == common.SystemData(server_id=server_id,
last_instance_id=123,
last_timestamp=t)
await flush(db)
db = await hat.event.server.backends.lmdb.systemdb.create(
executor=executor, env=env, name=name, server_id=server_id)
assert db.data == common.SystemData(server_id=server_id,
last_instance_id=123,
last_timestamp=t)
async def flush(db, now=None):
txn = await executor(env.begin, write=True)
if now is None:
now = common.now()
try:
await executor(db.create_ext_flush(), txn, now)
finally:
await executor(txn.commit)
def create_event(event_type, payload):
nonlocal counter
counter += 1
event_id = common.EventId(1, counter)
event = common.Event(event_id=event_id,
event_type=event_type,
timestamp=common.now(),
source_timestamp=None,
payload=payload)
return event
def create_event(event_type, with_source_timestamp):
nonlocal counter
counter += 1
event_id = common.EventId(1, counter)
t = common.now()
event = common.Event(
event_id=event_id,
event_type=event_type,
timestamp=t,
source_timestamp=(t if with_source_timestamp else None),
payload=None)
return event
async def test_limit_duration(executor, env, flush, query, create_event,
order_by):
name = 'name'
subscription = common.Subscription([('*', )])
conditions = hat.event.server.backends.lmdb.conditions.Conditions([])
limit = {'duration': 1}
db = await hat.event.server.backends.lmdb.ordereddb.create(
executor=executor,
env=env,
name=name,
subscription=subscription,
conditions=conditions,
order_by=order_by,
limit=limit)
t1 = common.now()
t2 = t1._replace(s=t1.s + 2 * limit['duration'])
t3 = t2._replace(s=t2.s + 2 * limit['duration'])
event1 = create_event(('a', ), True)._replace(timestamp=t1,
source_timestamp=t1)
event2 = create_event(('a', ), True)._replace(timestamp=t2,
source_timestamp=t2)
db.add(event1)
db.add(event2)
result = await query(db)
assert result == [event2, event1]
await flush(db, t2)
result = await query(db)
assert result == [event2]
await flush(db, t3)
result = await query(db)
assert result == []
def create_event(event_type, payload):
return common.Event(event_id=common.EventId(1, 2),
event_type=event_type,
timestamp=common.now(),
source_timestamp=None,
payload=payload)
def _ext_flush(env, db_flush_fns):
now = common.now()
with env.begin(write=True) as txn:
for db_flush_fn in db_flush_fns:
db_flush_fn(txn, now)
import pytest
from hat.event.server.backends.lmdb import common
import hat.event.server.backends.lmdb.encoder
@pytest.mark.parametrize('event', [
common.Event(event_id=common.EventId(1, 2),
event_type=('a', 'b', 'c'),
timestamp=common.now(),
source_timestamp=None,
payload=None)
])
def test_event(event):
encoded = hat.event.server.backends.lmdb.encoder.encode_event(event)
decoded = hat.event.server.backends.lmdb.encoder.decode_event(encoded)
assert event == decoded
@pytest.mark.parametrize('timestamp_id', [
(common.now(), 123)
])
def test_timestamp_id(timestamp_id):
encoded = hat.event.server.backends.lmdb.encoder.encode_timestamp_id(
timestamp_id)
decoded = hat.event.server.backends.lmdb.encoder.decode_timestamp_id(
encoded)
assert timestamp_id == decoded
@pytest.mark.parametrize('value', [
async def test_query_timestamps(executor, env, flush, query, create_event,
order_by, order):
name = 'name'
subscription = common.Subscription([('a', )])
conditions = hat.event.server.backends.lmdb.conditions.Conditions([])
db = await hat.event.server.backends.lmdb.ordereddb.create(
executor=executor,
env=env,
name=name,
subscription=subscription,
conditions=conditions,
order_by=order_by,
limit=None)
event1 = create_event(('a', ), True)
await asyncio.sleep(0.001)
event2 = create_event(('a', ), True)
await asyncio.sleep(0.001)
event3 = create_event(('a', ), True)
await asyncio.sleep(0.001)
event4 = create_event(('a', ), True)
await asyncio.sleep(0.001)
db.add(event1)
db.add(event2)
db.add(event3)
db.add(event4)
for _ in range(2):
result = await query(db, order=order)
if order == common.Order.DESCENDING:
assert result == [event4, event3, event2, event1]
elif order == common.Order.ASCENDING:
assert result == [event1, event2, event3, event4]
result = await query(db, order=order, t_from=event2.timestamp)
if order == common.Order.DESCENDING:
assert result == [event4, event3, event2]
elif order == common.Order.ASCENDING:
assert result == [event2, event3, event4]
result = await query(db,
order=order,
source_t_from=event2.source_timestamp)
if order == common.Order.DESCENDING:
assert result == [event4, event3, event2]
elif order == common.Order.ASCENDING:
assert result == [event2, event3, event4]
result = await query(db, order=order, t_to=event3.timestamp)
if order == common.Order.DESCENDING:
assert result == [event3, event2, event1]
elif order == common.Order.ASCENDING:
assert result == [event1, event2, event3]
result = await query(db,
order=order,
source_t_to=event3.source_timestamp)
if order == common.Order.DESCENDING:
assert result == [event3, event2, event1]
elif order == common.Order.ASCENDING:
assert result == [event1, event2, event3]
result = await query(db,
order=order,
t_from=event1.timestamp,
t_to=event4.timestamp,
source_t_from=event1.source_timestamp,
source_t_to=event4.source_timestamp)
if order == common.Order.DESCENDING:
assert result == [event4, event3, event2, event1]
elif order == common.Order.ASCENDING:
assert result == [event1, event2, event3, event4]
t = common.now()
result = await query(db,
order=order,
t_from=t,
t_to=t,
source_t_from=t,
source_t_to=t)
assert result == []
await flush(db)
