def test_opendatabaser():
"""
test contextmanager decorator for test databases
"""
with openLMDB() as databaser:
assert isinstance(databaser, LMDBer)
assert databaser.name == "test"
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.startswith("/tmp/keri_lmdb_")
assert databaser.path.endswith("_test/keri/db/test")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
assert databaser.opened
assert not os.path.exists(databaser.path)
assert not databaser.opened
with openLMDB(name="blue") as databaser:
assert isinstance(databaser, LMDBer)
assert databaser.name == "blue"
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.startswith("/tmp/keri_lmdb_")
assert databaser.path.endswith("_test/keri/db/blue")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
assert databaser.opened
assert not os.path.exists(databaser.path)
assert not databaser.opened
with openLMDB(name="red") as redbaser, openLMDB(name="tan") as tanbaser:
assert isinstance(redbaser, LMDBer)
assert redbaser.name == "red"
assert redbaser.env.path() == redbaser.path
assert os.path.exists(redbaser.path)
assert redbaser.opened
assert isinstance(tanbaser, LMDBer)
assert tanbaser.name == "tan"
assert tanbaser.env.path() == tanbaser.path
assert os.path.exists(tanbaser.path)
assert tanbaser.opened
assert not os.path.exists(redbaser.path)
assert not redbaser.opened
assert not os.path.exists(tanbaser.path)
assert not tanbaser.opened
""" End Test """
def test_serialization():
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
jim = Record(first="Jim",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
with dbing.openLMDB() as db:
k = basing.Komer(db=db, schema=Record, subdb='records.')
srl = k._serializer(Serials.mgpk)
expected = b'\x86\xa5first\xa3Jim\xa4last\xa5Black\xa6street\xaf100 Main Street\xa4city\xa8Riverton\xa5state\xa2UT\xa3zip\xce\x00\x01HZ'
assert srl(jim) == expected
srl = k._serializer(Serials.cbor)
expected = b'\xa6efirstcJimdlasteBlackfstreeto100 Main StreetdcityhRivertonestatebUTczip\x1a\x00\x01HZ'
assert srl(jim) == expected
srl = k._serializer(Serials.json)
expected = b'{"first":"Jim","last":"Black","street":"100 Main Street","city":"Riverton","state":"UT","zip":84058}'
assert srl(jim) == expected
def test_custom_serialization():
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
@staticmethod
def _der(d):
name = d["name"].split()
street = d["address1"]
city, state, z = d["address2"].split()
return Record(first=name[0],
last=name[1],
street=street,
city=city,
state=state,
zip=int(z, 10)
)
def _ser(self):
d = dict(
name="{} {}".format(self.first, self.last),
address1="{}".format(self.street),
address2="{} {} {}".format(self.city, self.state, self.zip)
)
return d
jim = Record(first="Jim",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
with dbing.openLMDB() as db:
mydb = koming.Komer(db=db, schema=Record, subkey='records.')
keys = ("test_key", "0001")
mydb.put(keys=keys, data=jim)
actual = mydb.get(keys=keys)
assert actual.first == "Jim"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
ser = db.getVal(mydb.sdb, mydb._tokey(keys))
assert ser == b'{"name":"Jim Black","address1":"100 Main Street","address2":"Riverton UT 84058"}'
def test_not_found_entity():
@dataclass
class Record:
first: str
def __iter__(self):
return iter(asdict(self))
with dbing.openLMDB() as db:
mydb = basing.Komer(db=db, schema=Record, subdb='records.')
sue = Record(first="Susan")
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(("not_found", "0001"))
assert actual is None
def test_kom_get_item_iter():
"""
Test Komer object class
"""
@dataclass
class Stuff:
a: str # dummy
b: str # dummy too
def __iter__(self):
return iter(asdict(self))
w = Stuff(a="Big", b="Blue")
x = Stuff(a="Tall", b="Red")
y = Stuff(a="Fat", b="Green")
z = Stuff(a="Eat", b="White")
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
mydb = koming.Komer(db=db, schema=Stuff, subkey='recs.')
assert isinstance(mydb, koming.Komer)
mydb.put(keys=("a", "1"), data=w)
mydb.put(keys=("a", "2"), data=x)
mydb.put(keys=("a", "3"), data=y)
mydb.put(keys=("a", "4"), data=z)
items = [(keys, asdict(data)) for keys, data in mydb.getItemIter()]
assert items == [(('a', '1'), {
'a': 'Big',
'b': 'Blue'
}), (('a', '2'), {
'a': 'Tall',
'b': 'Red'
}), (('a', '3'), {
'a': 'Fat',
'b': 'Green'
}), (('a', '4'), {
'a': 'Eat',
'b': 'White'
})]
assert not os.path.exists(db.path)
assert not db.opened
def test_deserialization():
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
msgp = b'\x86\xa5first\xa3Jim\xa4last\xa5Black\xa6street\xaf100 Main Street\xa4city\xa8Riverton\xa5state\xa2UT\xa3zip\xce\x00\x01HZ'
cbor = b'\xa6efirstcJimdlasteBlackfstreeto100 Main StreetdcityhRivertonestatebUTczip\x1a\x00\x01HZ'
json = b'{"first": "Jim", "last": "Black", "street": "100 Main Street", "city": "Riverton", "state": "UT", "zip": 84058}'
with dbing.openLMDB() as db:
k = basing.Komer(db=db, schema=Record, subdb='records.')
desrl = k._deserializer(Serials.mgpk)
actual = helping.datify(Record, desrl(msgp))
assert actual.first == "Jim"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
desrl = k._deserializer(Serials.json)
actual = helping.datify(Record, desrl(json))
assert actual.first == "Jim"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
desrl = k._deserializer(Serials.cbor)
actual = helping.datify(Record, desrl(cbor))
assert actual.first == "Jim"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
def test_put_invalid_dataclass():
@dataclass
class Record:
first: str
def __iter__(self):
return iter(asdict(self))
@dataclass
class AnotherClass:
age: int
with dbing.openLMDB() as db:
mydb = basing.Komer(db=db, schema=AnotherClass, subdb='records.')
sue = Record(first="Susan")
keys = ("test_key", "0001")
with pytest.raises(ValueError):
mydb.put(keys=keys, data=sue)
def test_serder_suber():
"""
Test SerderSuber LMDBer sub database class
"""
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.SerderSuber(db=db, subkey='bags.')
assert isinstance(sdb, subing.SerderSuber)
pre = "BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc"
srdr0 = eventing.incept(keys=[pre])
keys = (pre, srdr0.dig)
sdb.put(keys=keys, srdr=srdr0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Serder)
assert actual.dig == srdr0.dig
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, srdr=srdr0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Serder)
assert actual.dig == srdr0.dig
srdr1 = eventing.rotate(pre=pre, keys=[pre], dig=srdr0.dig)
result = sdb.put(keys=keys, srdr=srdr1)
assert not result
assert isinstance(actual, coring.Serder)
assert actual.dig == srdr0.dig
result = sdb.pin(keys=keys, srdr=srdr1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Serder)
assert actual.dig == srdr1.dig
# test with keys as string not tuple
keys = "{}.{}".format(pre, srdr1.dig)
sdb.put(keys=keys, srdr=srdr1)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Serder)
assert actual.dig == srdr1.dig
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
# test missing entry at keys
badkey = "badkey"
actual = sdb.get(badkey)
assert actual is None
# test iteritems
sdb = subing.SerderSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.SerderSuber)
sdb.put(keys=("a", "1"), srdr=srdr0)
sdb.put(keys=("a", "2"), srdr=srdr1)
items = [(keys, srdr.dig) for keys, srdr in sdb.getItemIter()]
assert items == [(('a', '1'), srdr0.dig), (('a', '2'), srdr1.dig)]
assert not os.path.exists(db.path)
assert not db.opened
def test_matter_suber():
"""
Test MatterSuber LMDBer sub database class
"""
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.MatterSuber(db=db,
subkey='bags.') # default klas is Matter
assert isinstance(sdb, subing.MatterSuber)
assert issubclass(sdb.klas, coring.Matter)
pre0 = "BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc"
val0 = coring.Matter(qb64=pre0)
keys = ("alpha", "dog")
sdb.put(keys=keys, val=val0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Matter)
assert actual.qb64 == val0.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=val0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Matter)
assert actual.qb64 == val0.qb64
pre1 = "BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc"
val1 = coring.Matter(qb64=pre1)
result = sdb.put(keys=keys, val=val1)
assert not result
assert isinstance(actual, coring.Matter)
assert actual.qb64 == val0.qb64
result = sdb.pin(keys=keys, val=val1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Matter)
assert actual.qb64 == val1.qb64
# test with keys as string not tuple
keys = "{}.{}".format("beta", "fish")
sdb.put(keys=keys, val=val1)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Matter)
assert actual.qb64 == val1.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
# test missing entry at keys
badkey = "badkey"
actual = sdb.get(badkey)
assert actual is None
# test iteritems
sdb = subing.MatterSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.MatterSuber)
sdb.put(keys=("a", "1"), val=val0)
sdb.put(keys=("a", "2"), val=val1)
items = [(keys, srdr.qb64) for keys, srdr in sdb.getItemIter()]
assert items == [(('a', '1'), val0.qb64), (('a', '2'), val1.qb64)]
# Try other classs
sdb = subing.MatterSuber(db=db, subkey='pigs.', klas=coring.Diger)
assert isinstance(sdb, subing.MatterSuber)
assert issubclass(sdb.klas, coring.Diger)
dig0 = "EQPYGGwTmuupWzwEHHzq7K0gzUhPx5_yZ-Wk1x4ejhcc"
val0 = coring.Diger(qb64=dig0)
keys = ("alpha", "dog")
sdb.put(keys=keys, val=val0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Diger)
assert actual.qb64 == val0.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=val0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Diger)
assert actual.qb64 == val0.qb64
pre1 = "EHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc"
val1 = coring.Matter(qb64=pre1)
result = sdb.put(keys=keys, val=val1)
assert not result
assert isinstance(actual, coring.Diger)
assert actual.qb64 == val0.qb64
result = sdb.pin(keys=keys, val=val1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Diger)
assert actual.qb64 == val1.qb64
# test iteritems
sdb = subing.MatterSuber(db=db, subkey='figs.')
assert isinstance(sdb, subing.MatterSuber)
sdb.put(keys=("a", "1"), val=val0)
sdb.put(keys=("a", "2"), val=val1)
items = [(keys, srdr.qb64) for keys, srdr in sdb.getItemIter()]
assert items == [(('a', '1'), val0.qb64), (('a', '2'), val1.qb64)]
assert not os.path.exists(db.path)
assert not db.opened
def test_suber():
"""
Test Suber LMDBer sub database class
"""
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.Suber(db=db, subkey='bags.')
assert isinstance(sdb, subing.Suber)
sue = "Hello sailer!"
keys = ("test_key", "0001")
sdb.put(keys=keys, val=sue)
actual = sdb.get(keys=keys)
assert actual == sue.encode("utf-8")
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=sue)
actual = sdb.get(keys=keys)
assert actual == sue.encode("utf-8")
kip = "Hey gorgeous!"
result = sdb.put(keys=keys, val=kip)
assert not result
actual = sdb.get(keys=keys)
assert actual == sue.encode("utf-8")
result = sdb.pin(keys=keys, val=kip)
assert result
actual = sdb.get(keys=keys)
assert actual == kip.encode("utf-8")
# test with keys as string not tuple
keys = "keystr"
bob = "Shove off!"
sdb.put(keys=keys, val=bob)
actual = sdb.get(keys=keys)
assert actual == bob.encode("utf-8")
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
liz = "May live is insane."
keys = ("test_key", "0002")
sdb.put(keys=keys, val=liz)
actual = sdb.get(("not_found", "0002"))
assert actual is None
w = "Blue dog"
x = "Green tree"
y = "Red apple"
z = "White snow"
sdb = subing.Suber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.Suber)
sdb.put(keys=("a", "1"), val=w)
sdb.put(keys=("a", "2"), val=x)
sdb.put(keys=("a", "3"), val=y)
sdb.put(keys=("a", "4"), val=z)
items = [(keys, data.decode("utf-8"))
for keys, data in sdb.getItemIter()]
assert items == [(('a', '1'), w), (('a', '2'), x), (('a', '3'), y),
(('a', '4'), z)]
assert not os.path.exists(db.path)
assert not db.opened
def test_issuer():
"""
Test Issuer Class
"""
issuer = Registry()
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/db/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
# test not opened on init
issuer = Registry(reopen=False)
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert issuer.opened is False
assert issuer.path is None
assert issuer.env is None
issuer.reopen()
assert issuer.opened
assert issuer.path is not None
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/db/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
assert isinstance(issuer.tvts, lmdb._Database)
with openLMDB(cls=Registry) as issuer:
assert isinstance(issuer, Registry)
assert issuer.name == "test"
assert issuer.temp is True
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.startswith("/tmp/keri_lmdb_")
assert issuer.path.endswith("_test/keri/db/test")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
assert not os.path.exists(issuer.path)
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regb = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
# test with registry inception (vcp) event
regk = nsKey([ipreb, regb])
assert regk == b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert vcpb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0",'
b'"s":"0","b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],"t":"vcp"}'
)
vdig = Diger(ser=vcpb)
with openLMDB(cls=Registry) as issuer:
key = dgKey(regk, vdig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.putTvt(key, val=vcpb) is False
assert issuer.setTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(regk, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=vdig.qb64b)
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.putTel(telKey, val=vdig.qb64b) is False
assert issuer.setTel(telKey, val=vdig.qb64b) is True
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
coupl01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
coupl02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
coupl03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
coups = [coupl01, coupl02, coupl03]
key = dgKey(regk, vdig.qb64b)
assert issuer.getTibs(key) == []
assert issuer.cntTibs(key) == 0
assert issuer.delTibs(key) is False
assert issuer.putTibs(key, vals=[coupl01]) is True
assert issuer.getTibs(key) == [coupl01]
assert issuer.cntTibs(key) == 1
assert issuer.putTibs(key, vals=[coupl01]) is True # add duplicate
assert issuer.cntTibs(key) == 1
assert issuer.addTib(key, coupl01) is False
assert issuer.addTib(key, coupl02) is True
assert issuer.cntTibs(key) == 2
assert issuer.putTibs(key, vals=[coupl02, coupl03]) is True
assert issuer.cntTibs(key) == 3
assert issuer.delTibs(key) is True
assert issuer.getTibs(key) == []
for c in coups:
assert issuer.addTib(key, c) is True
assert issuer.cntTibs(key) == 3
assert issuer.getTibs(key) == [coupl01, coupl02, coupl03]
for c in issuer.getTibsIter(key):
assert issuer.delTibs(key, c) is True
assert issuer.getTibs(key) == []
tweKey = snKey(regk, sn)
assert issuer.getTwe(tweKey) is None
assert issuer.delTwe(tweKey) is False
assert issuer.putTwe(tweKey, val=vdig.qb64b)
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.putTwe(tweKey, val=vdig.qb64b) is False
assert issuer.setTwe(tweKey, val=vdig.qb64b) is True
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.delTwe(tweKey) is True
assert issuer.getTwe(tweKey) is None
ooKey = snKey(regk, sn)
assert issuer.getOot(ooKey) is None
assert issuer.delOot(ooKey) is False
assert issuer.putOot(ooKey, val=vdig.qb64b)
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.putOot(ooKey, val=vdig.qb64b) is False
assert issuer.setOot(ooKey, val=vdig.qb64b) is True
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.delOot(ooKey) is True
assert issuer.getOot(ooKey) is None
anc01 = (
"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo"
"0AAAAAAAAAAAAAAAAAAAAABA"
"Ezpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4").encode("utf-8")
key = dgKey(regk, vdig.qb64b)
assert issuer.getAnc(key) is None
assert issuer.delAnc(key) is False
assert issuer.putAnc(key, val=anc01)
assert issuer.getAnc(key) == anc01
assert issuer.putAnc(key, val=anc01) is False
assert issuer.setAnc(key, val=anc01) is True
assert issuer.getAnc(key) == anc01
assert issuer.delAnc(key) is True
assert issuer.getAnc(key) is None
# test with verifiable credential issuance (iss) event
vcdig = b'EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc'
vck = nsKey([ipreb, regb, vcdig])
assert vck == (
b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
b':EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc')
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs, i=vck.decode("utf-8"), s="{:x}".format(sn), t="iss")
issb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert issb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:'
b'EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0:EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc",'
b''
b'"s":"0","t":"iss"}')
idig = Diger(ser=issb)
key = dgKey(vck, idig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.putTvt(key, val=issb) is False
assert issuer.setTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(vck, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=idig.qb64b)
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.putTel(telKey, val=idig.qb64b) is False
assert issuer.setTel(telKey, val=idig.qb64b) is True
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
"""End Test"""
def test_pocketer():
pocket = Pocketer()
assert isinstance(pocket, Pocketer)
assert pocket.name == "main"
assert pocket.temp is False
assert isinstance(pocket.env, lmdb.Environment)
assert pocket.path.endswith("keri/pck/main")
assert pocket.env.path() == pocket.path
assert os.path.exists(pocket.path)
assert isinstance(pocket.sers, lmdb._Database)
pocket.close(clear=True)
assert not os.path.exists(pocket.path)
assert not pocket.opened
# test not opened on init
pocket = Pocketer(reopen=False)
assert isinstance(pocket, Pocketer)
assert pocket.name == "main"
assert pocket.temp is False
assert pocket.opened is False
assert pocket.path is None
assert pocket.env is None
pocket.reopen()
assert pocket.opened
assert pocket.path is not None
assert isinstance(pocket.env, lmdb.Environment)
assert pocket.path.endswith("keri/pck/main")
assert pocket.env.path() == pocket.path
assert os.path.exists(pocket.path)
pocket.close(clear=True)
assert not os.path.exists(pocket.path)
assert not pocket.opened
assert isinstance(pocket.issus, lmdb._Database)
with openLMDB(cls=Pocketer) as pocket:
assert isinstance(pocket, Pocketer)
assert pocket.name == "test"
assert pocket.temp is True
assert isinstance(pocket.env, lmdb.Environment)
assert pocket.path.startswith("/tmp/keri_pck_")
assert pocket.path.endswith("_test/keri/pck/test")
assert pocket.env.path() == pocket.path
assert os.path.exists(pocket.path)
assert isinstance(pocket.subjs, lmdb._Database)
assert not os.path.exists(pocket.path)
with openPocket(name="test") as pocket:
key = "Eb87ZrHEOxPShWXjrg2XjGXYKYf35IIA7XCJSc8eeuR0"
issuer = b'EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc'
subject = b'E7NDc95Rgl959Wh1r3dzCAGaQ6zGduFaJrD-ORbEXr_U'
schema = b'EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
key = key.encode("utf-8")
assert pocket.getSigs(key) == []
assert pocket.cntSigs(key) == 0
assert pocket.delSigs(key) == False
sig0b = 'AAz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQ'.encode("utf-8")
sig1b = 'AB_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z'.encode("utf-8")
# dup vals are lexocographic
assert pocket.putSigs(key, vals=[b"z", b"m", b"x", b"a"]) == True
assert pocket.getSigs(key) == [b'a', b'm', b'x', b'z']
assert pocket.cntSigs(key) == 4
assert pocket.putSigs(key, vals=[b'a']) == True # duplicate but True
assert pocket.getSigs(key) == [b'a', b'm', b'x', b'z']
assert pocket.addSig(key, b'a') == False # duplicate
assert pocket.addSig(key, b'b') == True
assert pocket.getSigs(key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in pocket.getSigsIter(key)] == [b'a', b'b', b'm', b'x', b'z']
assert pocket.delSigs(key) == True
assert pocket.getSigs(key) == []
vals = [b"z", b"m", b"x", b"a"]
assert pocket.putSigs(key, vals) == True
for val in vals:
assert pocket.delSigs(key, val) == True
assert pocket.getSigs(key) == []
assert pocket.putSigs(key, vals) == True
for val in pocket.getSigsIter(key):
assert pocket.delSigs(key, val) == True
assert pocket.getSigs(key) == []
assert pocket.putSigs(key, vals=[sig0b]) == True
assert pocket.getSigs(key) == [sig0b]
assert pocket.putSigs(key, vals=[sig1b]) == True
assert pocket.getSigs(key) == [sig0b, sig1b]
assert pocket.delSigs(key) == True
assert pocket.putSigs(key, vals=[sig1b, sig0b]) == True
assert pocket.getSigs(key) == [sig0b, sig1b]
assert pocket.delSigs(key) == True
assert pocket.getSigs(key) == []
cred1 = b'EhUlGZJ_-xyYy__IMRS4vHRB27EU4tDdUB7swE3pUvXU'
cred2 = b'EvcZT4uLfeHRJV48J-f4n3MNzwQ-GX0Ogw7DkkaSKkR4'
cred3 = b'EmZZhv2sSzM7lyIEBmdseYkKbOvTV6dBSW_30heEqICE'
cred4 = b'EyFSfdyHfPBs-lSHc7k7TqeAXotT5jcJ8Z-vj5h8tHRc'
cred5 = b'EvYB417eijN1IrClN8KpzqTi4oWJUgtEUhSIy-_W2C4o'
creds = [cred1, cred2, cred3, cred4]
assert pocket.getIssus(issuer) == []
assert pocket.cntIssus(issuer) == 0
assert pocket.delIssus(issuer) is False
assert pocket.putIssus(issuer, creds) is True
assert pocket.getIssus(issuer) == creds
assert pocket.cntIssus(issuer) == len(creds) == 4
assert pocket.putIssus(issuer, vals=[cred2]) is False
assert pocket.getIssus(issuer) == creds
assert pocket.addIssu(issuer, b'EhUlGZJ_-xyYy__IMRS4vHRB27EU4tDdUB7swE3pUvXU') is False
assert pocket.addIssu(issuer, cred5) is True
assert pocket.getIssus(issuer) == [cred1, cred2, cred3, cred4, cred5]
assert [val for val in pocket.getIssusIter(issuer)] == [cred1, cred2, cred3, cred4, cred5]
assert pocket.delIssus(issuer) is True
assert pocket.getIssus(issuer) == []
assert pocket.getSubjs(subject) == []
assert pocket.cntSubjs(subject) == 0
assert pocket.delSubjs(subject) is False
assert pocket.putSubjs(subject, creds) is True
assert pocket.getSubjs(subject) == creds
assert pocket.cntSubjs(subject) == len(creds) == 4
assert pocket.putSubjs(subject, vals=[cred2]) is False
assert pocket.getSubjs(subject) == creds
assert pocket.addSubj(subject, b'EhUlGZJ_-xyYy__IMRS4vHRB27EU4tDdUB7swE3pUvXU') is False
assert pocket.addSubj(subject, cred5) is True
assert pocket.getSubjs(subject) == [cred1, cred2, cred3, cred4, cred5]
assert [val for val in pocket.getSubjsIter(subject)] == [cred1, cred2, cred3, cred4, cred5]
assert pocket.delSubjs(subject) is True
assert pocket.getSubjs(subject) == []
assert pocket.getSchms(schema) == []
assert pocket.cntSchms(schema) == 0
assert pocket.delSchms(schema) is False
assert pocket.putSchms(schema, creds) is True
assert pocket.getSchms(schema) == creds
assert pocket.cntSchms(schema) == len(creds) == 4
assert pocket.putSchms(schema, vals=[cred2]) is False
assert pocket.getSchms(schema) == creds
assert pocket.addSchm(schema, b'EhUlGZJ_-xyYy__IMRS4vHRB27EU4tDdUB7swE3pUvXU') is False
assert pocket.addSchm(schema, cred5) is True
assert pocket.getSchms(schema) == [cred1, cred2, cred3, cred4, cred5]
assert [val for val in pocket.getSchmsIter(schema)] == [cred1, cred2, cred3, cred4, cred5]
assert pocket.delSchms(schema) is True
assert pocket.getSchms(schema) == []
def test_crypt_signer_suber():
"""
test Manager class with aeid
"""
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed0 = (
b'\x18;0\xc4\x0f*vF\xfa\xe3\xa2Eee\x1f\x96o\xce)G\x85\xe3X\x86\xda\x04\xf0\xdc'
b'\xde\x06\xc0+')
signer0 = coring.Signer(raw=seed0, code=coring.MtrDex.Ed25519_Seed)
assert signer0.verfer.code == coring.MtrDex.Ed25519
assert signer0.verfer.transferable # default
assert signer0.qb64b == b'AGDswxA8qdkb646JFZWUflm_OKUeF41iG2gTw3N4GwCs'
assert signer0.verfer.qb64b == b'DhixhZjC1Wj2bLR1QdADT79kS2zwHld29ekca0elxHiE'
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed1 = (
b'`\x05\x93\xb9\x9b6\x1e\xe0\xd7\x98^\x94\xc8Et\xf2\xc4\xcd\x94\x18'
b'\xc6\xae\xb9\xb6m\x12\xc4\x80\x03\x07\xfc\xf7')
signer1 = coring.Signer(raw=seed1, code=coring.MtrDex.Ed25519_Seed)
assert signer1.verfer.code == coring.MtrDex.Ed25519
assert signer1.verfer.transferable # default
assert signer1.qb64b == b'AYAWTuZs2HuDXmF6UyEV08sTNlBjGrrm2bRLEgAMH_Pc'
assert signer1.verfer.qb64b == b'Dgekf6SB_agwx96mVSZI6PTC09j4Sp8qUbgKglN8uLjY'
# rawsalt =pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES)
rawsalt = b'0123456789abcdef'
salter = coring.Salter(raw=rawsalt)
salt = salter.qb64
assert salt == '0AMDEyMzQ1Njc4OWFiY2RlZg'
stem = "blue"
# cryptseed0 = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
cryptseed0 = b'h,#|\x8ap"\x12\xc43t2\xa6\xe1\x18\x19\xf0f2,y\xc4\xc21@\xf5@\x15.\xa2\x1a\xcf'
cryptsigner0 = coring.Signer(raw=cryptseed0,
code=coring.MtrDex.Ed25519_Seed,
transferable=False)
seed0 = cryptsigner0.qb64
aeid0 = cryptsigner0.verfer.qb64
assert aeid0 == 'BJruYr3oXDGRTRN0XnhiqDeoENdRak6FD8y2vsTvvJkE'
decrypter = coring.Decrypter(seed=seed0)
encrypter = coring.Encrypter(verkey=aeid0)
assert encrypter.verifySeed(seed=seed0)
# cryptseed1 = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
cryptseed1 = (
b"\x89\xfe{\xd9'\xa7\xb3\x89#\x19\xbec\xee\xed\xc0\xf9\x97\xd0\x8f9\x1dyNI"
b'I\x98\xbd\xa4\xf6\xfe\xbb\x03')
cryptsigner1 = coring.Signer(raw=cryptseed1,
code=coring.MtrDex.Ed25519_Seed,
transferable=False)
with dbing.openLMDB() as db, keeping.openKS() as ks:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.CryptSignerSuber(db=db,
subkey='bags.') # default klas is Signer
assert isinstance(sdb, subing.CryptSignerSuber)
assert issubclass(sdb.klas, coring.Signer)
# Test without encrypter or decrypter
keys = (signer0.verfer.qb64,
) # must be verfer as key to get transferable
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# try put different val when already put
result = sdb.put(keys=keys, val=signer1)
assert not result
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# now overwrite with pin. Key is wrong but transferable property is
# the same so that is all that matters to get back signer
result = sdb.pin(keys=keys, val=signer1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer1.qb64
assert actual.verfer.qb64 == signer1.verfer.qb64
# test with keys as string not tuple
keys = signer0.verfer.qb64
sdb.pin(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
assert not sdb.get(keys=keys)
# test missing entry at keys
badkey = b'D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE'
assert not sdb.get(badkey)
# test iteritems
sdb = subing.CryptSignerSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.CryptSignerSuber)
assert sdb.put(keys=signer0.verfer.qb64b, val=signer0)
assert sdb.put(keys=signer1.verfer.qb64b, val=signer1)
items = [(keys, sgnr.qb64) for keys, sgnr in sdb.getItemIter()]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# now test with encrypter and decrypter
encrypter0 = coring.Encrypter(verkey=cryptsigner0.verfer.qb64)
decrypter0 = coring.Decrypter(seed=cryptsigner0.qb64b)
# first pin with encrypter
assert sdb.pin(keys=signer0.verfer.qb64b,
val=signer0,
encrypter=encrypter0)
assert sdb.pin(keys=signer1.verfer.qb64b,
val=signer1,
encrypter=encrypter0)
# now get
actual0 = sdb.get(keys=signer0.verfer.qb64b, decrypter=decrypter0)
assert isinstance(actual0, coring.Signer)
assert actual0.qb64 == signer0.qb64
assert actual0.verfer.qb64 == signer0.verfer.qb64
actual1 = sdb.get(keys=signer1.verfer.qb64b, decrypter=decrypter0)
assert isinstance(actual1, coring.Signer)
assert actual1.qb64 == signer1.qb64
assert actual1.verfer.qb64 == signer1.verfer.qb64
# now get without decrypter
with pytest.raises(ValueError):
actual0 = sdb.get(keys=signer0.verfer.qb64b)
with pytest.raises(ValueError):
actual1 = sdb.get(keys=signer1.verfer.qb64b)
# remove and test put
sdb.rem(keys=signer0.verfer.qb64b)
assert not sdb.get(keys=signer0.verfer.qb64b)
sdb.rem(keys=signer1.verfer.qb64b)
assert not sdb.get(keys=signer1.verfer.qb64b)
assert sdb.put(keys=signer0.verfer.qb64b,
val=signer0,
encrypter=encrypter0)
assert sdb.put(keys=signer1.verfer.qb64b,
val=signer1,
encrypter=encrypter0)
items = [(keys, sgnr.qb64)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter0)]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# test re-encrypt
encrypter1 = coring.Encrypter(verkey=cryptsigner1.verfer.qb64)
decrypter1 = coring.Decrypter(seed=cryptsigner1.qb64b)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter0):
sdb.pin(keys, sgnr, encrypter=encrypter1)
items = [(keys, sgnr.qb64)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter1)]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# now test with manager
manager = keeping.Manager(
ks=ks,
seed=seed0,
salt=salt,
aeid=aeid0,
)
assert manager.ks.opened
assert manager.inited
assert manager._inits == {
'aeid': 'BJruYr3oXDGRTRN0XnhiqDeoENdRak6FD8y2vsTvvJkE',
'salt': '0AMDEyMzQ1Njc4OWFiY2RlZg'
}
assert manager.encrypter.qb64 == encrypter.qb64 # aeid provided
assert manager.decrypter.qb64 == decrypter.qb64 # aeid and seed provided
assert manager.seed == seed0 # in memory only
assert manager.aeid == aeid0 # on disk only
assert manager.salt == salt # encrypted on disk but property decrypts if seed
assert manager.pidx == 0
assert manager.tier == coring.Tiers.low
saltCipher0 = coring.Cipher(qb64=manager.ks.gbls.get('salt'))
assert saltCipher0.decrypt(seed=seed0).qb64 == salt
manager.updateAeid(aeid=cryptsigner1.verfer.qb64,
seed=cryptsigner1.qb64)
assert manager.aeid == cryptsigner1.verfer.qb64 == 'BRw6sysb_uv81ZouXqHxQlqnAh9BYiSOsg9eQJmbZ8Uw'
assert manager.salt == salt
saltCipher1 = coring.Cipher(qb64=manager.ks.gbls.get('salt'))
assert not saltCipher0.qb64 == saltCipher1.qb64 # old cipher different
"""End Test"""
def test_signer_suber():
"""
Test SignerSuber LMDBer sub database class
"""
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.SignerSuber(db=db,
subkey='bags.') # default klas is Signer
assert isinstance(sdb, subing.SignerSuber)
assert issubclass(sdb.klas, coring.Signer)
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed0 = (
b'\x18;0\xc4\x0f*vF\xfa\xe3\xa2Eee\x1f\x96o\xce)G\x85\xe3X\x86\xda\x04\xf0\xdc'
b'\xde\x06\xc0+')
signer0 = coring.Signer(raw=seed0, code=coring.MtrDex.Ed25519_Seed)
assert signer0.verfer.code == coring.MtrDex.Ed25519
assert signer0.verfer.transferable # default
assert signer0.qb64b == b'AGDswxA8qdkb646JFZWUflm_OKUeF41iG2gTw3N4GwCs'
assert signer0.verfer.qb64b == b'DhixhZjC1Wj2bLR1QdADT79kS2zwHld29ekca0elxHiE'
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed1 = (
b'`\x05\x93\xb9\x9b6\x1e\xe0\xd7\x98^\x94\xc8Et\xf2\xc4\xcd\x94\x18'
b'\xc6\xae\xb9\xb6m\x12\xc4\x80\x03\x07\xfc\xf7')
signer1 = coring.Signer(raw=seed1, code=coring.MtrDex.Ed25519_Seed)
assert signer1.verfer.code == coring.MtrDex.Ed25519
assert signer1.verfer.transferable # default
assert signer1.qb64b == b'AYAWTuZs2HuDXmF6UyEV08sTNlBjGrrm2bRLEgAMH_Pc'
assert signer1.verfer.qb64b == b'Dgekf6SB_agwx96mVSZI6PTC09j4Sp8qUbgKglN8uLjY'
keys = (signer0.verfer.qb64,
) # must be verfer as key to get transferable
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# try put different val when already put
result = sdb.put(keys=keys, val=signer1)
assert not result
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# now overwrite with pin. Key is wrong but transferable property is
# the same so that is all that matters to get back signer
result = sdb.pin(keys=keys, val=signer1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer1.qb64
assert actual.verfer.qb64 == signer1.verfer.qb64
# test with keys as string not tuple
keys = signer0.verfer.qb64
sdb.pin(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
assert not sdb.get(keys=keys)
# test missing entry at keys
badkey = b'D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE'
assert not sdb.get(badkey)
# test iteritems
sdb = subing.SignerSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.SignerSuber)
assert sdb.put(keys=signer0.verfer.qb64b, val=signer0)
assert sdb.put(keys=signer1.verfer.qb64b, val=signer1)
items = [(keys, srdr.qb64) for keys, srdr in sdb.getItemIter()]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
assert not os.path.exists(db.path)
assert not db.opened
def test_store_exchanger():
with dbing.openLMDB(cls=Mailboxer) as mber, \
basing.openDB(name="test") as db, \
keeping.openKS(name="test") as ks:
salt = coring.Salter(raw=b'0123456789abcdef').qb64
hab = habbing.Habitat(ks=ks, db=db, salt=salt, temp=True)
exchr = exchanging.StoreExchanger(hab=hab, mbx=mber)
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
siger = coring.Siger(
qb64=
"AAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA"
)
d = dict(a="b", b=123)
exn = exchanging.exchange("/credential/issue",
payload=d,
date="2021-07-15T13:01:37.624492+00:00")
with pytest.raises(MissingSignatureError):
exchr.processEvent(serder=exn, source=source, sigers=[siger])
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
with pytest.raises(MissingDestinationError):
exchr.processEvent(serder=exn, source=source, sigers=sigers)
for idx in range(10):
d = dict(a="b", b=idx)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
exchr.processEvent(serder=exn, source=source, sigers=sigers)
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=0):
msgs.append(msg)
assert (len(msgs)) == 10
for idx, msg in enumerate(msgs):
exn = coring.Serder(msg)
d = exn.ked["q"]
assert d["b"] == idx
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=10):
msgs.append(msg)
assert (len(msgs)) == 0
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=4):
msgs.append(msg)
assert (len(msgs)) == 6
def test_mailboxing():
"""
Test Mailboxer Class
"""
mber = Mailboxer()
assert isinstance(mber, Mailboxer)
assert mber.name == "main"
assert mber.temp is False
assert isinstance(mber.env, lmdb.Environment)
assert mber.path.endswith("keri/mbx/main")
assert mber.env.path() == mber.path
assert os.path.exists(mber.path)
assert isinstance(mber.fels, lmdb._Database)
mber.close(clear=True)
assert not os.path.exists(mber.path)
assert not mber.opened
mber = Mailboxer(reopen=False)
assert isinstance(mber, Mailboxer)
assert mber.name == "main"
assert mber.temp is False
assert mber.opened is False
assert mber.path is None
assert mber.env is None
mber.reopen()
assert mber.opened
assert mber.path is not None
assert isinstance(mber.env, lmdb.Environment)
assert mber.path.endswith("keri/mbx/main")
assert mber.env.path() == mber.path
assert os.path.exists(mber.path)
mber.close(clear=True)
assert not os.path.exists(mber.path)
assert not mber.opened
assert isinstance(mber.exns, subing.SerderSuber)
with dbing.openLMDB(cls=Mailboxer) as mber:
assert isinstance(mber, Mailboxer)
msg = bytearray(
b'{"v":"KERI10JSON0000ac_","t":"exn","i":"E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I",'
b'"dt":"2021-07-15T13:01:37.624492+00:00","r":"/credential/issue","q":{"a":"b",'
b'"b":123}}-HABE4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E'
b'-AABAAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA'
)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
siger = coring.Siger(
qb64=
"AAMKEkKlqSYcAbOHfNXQ_D0Rbj9bQD5FqhFqckAlDnOFozRKOIPrCWaszRzSUN20UBj80tO5ozN35KrQp9m7Z1AA"
)
d = dict(a="b", b=123)
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
mber.storeEvent(serder=exn, source=source, dest=dest, sigers=[siger])
actual = mber.cloneEvtMsg(dig=exn.digb)
assert actual == msg
assert not os.path.exists(mber.path)
with dbing.openLMDB(cls=Mailboxer) as mber, \
basing.openDB(name="test") as db, \
keeping.openKS(name="test") as ks:
salt = coring.Salter(raw=b'0123456789abcdef').qb64
hab = habbing.Habitat(ks=ks, db=db, salt=salt, temp=True)
for idx in range(10):
d = dict(a="b", b=idx)
dest = coring.Prefixer(
qb64="E4D919wF4oiG7ck6mnBWTRD_Z-Io0wZKCxL0zjx5je9I")
source = coring.Prefixer(
qb64="E4YPqsEOaPNaZxVIbY-Gx2bJgP-c7AH_K7pEE-YfcI9E")
exn = exchanging.exchange("/credential/issue",
payload=d,
recipient=dest.qb64,
date="2021-07-15T13:01:37.624492+00:00")
sigers = hab.mgr.sign(ser=exn.raw, verfers=hab.kever.verfers)
mber.storeEvent(serder=exn,
source=source,
dest=dest,
sigers=sigers)
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=0):
msgs.append(msg)
assert (len(msgs)) == 10
for idx, msg in enumerate(msgs):
exn = coring.Serder(msg)
d = exn.ked["q"]
assert d["b"] == idx
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=10):
msgs.append(msg)
assert (len(msgs)) == 0
msgs = []
for msg in mber.clonePreIter(pre=dest.qb64b, fn=4):
msgs.append(msg)
assert (len(msgs)) == 6
def test_kom_happy_path():
"""
Test Komer object class
"""
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
def __iter__(self):
return iter(asdict(self))
jim = Record(first="Jim",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
jimser = json.dumps(asdict(jim)).encode("utf-8")
jim = helping.datify(Record, json.loads(bytes(jimser).decode("utf-8")))
assert isinstance(jim, Record)
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
mydb = koming.Komer(db=db, schema=Record, subkey='records.')
assert isinstance(mydb, koming.Komer)
sue = Record(first="Susan",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(keys=keys)
assert actual.first == "Susan"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
mydb.rem(keys)
actual = mydb.get(keys=keys)
assert actual is None
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(keys=keys)
assert actual == sue
kip = Record(first="Kip",
last="Thorne",
street="200 Center Street",
city="Bluffdale",
state="UT",
zip=84043)
result = mydb.put(keys=keys, data=kip)
assert not result
actual = mydb.get(keys=keys)
assert actual == sue
result = mydb.pin(keys=keys, data=kip)
assert result
actual = mydb.get(keys=keys)
assert actual == kip
# test with keys as string not tuple
keys = "keystr"
bob = Record(first="Bob",
last="Brown",
street="100 Center Street",
city="Bluffdale",
state="UT",
zip=84043)
mydb.put(keys=keys, data=bob)
actual = mydb.get(keys=keys)
assert actual.first == "Bob"
assert actual.last == "Brown"
assert actual.street == "100 Center Street"
assert actual.city == "Bluffdale"
assert actual.state == "UT"
assert actual.zip == 84043
mydb.rem(keys)
actual = mydb.get(keys=keys)
assert actual is None
assert not os.path.exists(db.path)
assert not db.opened
def test_issuer():
"""
Test Issuer Class
"""
issuer = Registry()
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/reg/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
# test not opened on init
issuer = Registry(reopen=False)
assert isinstance(issuer, Registry)
assert issuer.name == "main"
assert issuer.temp is False
assert issuer.opened is False
assert issuer.path is None
assert issuer.env is None
issuer.reopen()
assert issuer.opened
assert issuer.path is not None
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.endswith("keri/reg/main")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
issuer.close(clear=True)
assert not os.path.exists(issuer.path)
assert not issuer.opened
assert isinstance(issuer.tvts, lmdb._Database)
with openLMDB(cls=Registry) as issuer:
assert isinstance(issuer, Registry)
assert issuer.name == "test"
assert issuer.temp is True
assert isinstance(issuer.env, lmdb.Environment)
assert issuer.path.startswith("/tmp/keri_reg_")
assert issuer.path.endswith("_test/keri/reg/test")
assert issuer.env.path() == issuer.path
assert os.path.exists(issuer.path)
assert isinstance(issuer.tvts, lmdb._Database)
assert not os.path.exists(issuer.path)
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regb = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
# test with registry inception (vcp) event
regk = nsKey([ipreb, regb])
assert regk == b'DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert vcpb == (
b'{"v":"KERI10JSON000014_",'
b'"i":"DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo:EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0",'
b'"s":"0","b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],"t":"vcp"}'
)
vdig = Diger(ser=vcpb)
with openLMDB(cls=Registry) as issuer:
key = dgKey(regk, vdig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.putTvt(key, val=vcpb) is False
assert issuer.setTvt(key, val=vcpb) is True
assert issuer.getTvt(key) == vcpb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(regk, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=vdig.qb64b)
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.putTel(telKey, val=vdig.qb64b) is False
assert issuer.setTel(telKey, val=vdig.qb64b) is True
assert issuer.getTel(telKey) == vdig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
coupl01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
coupl02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
coupl03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
coups = [coupl01, coupl02, coupl03]
key = dgKey(regk, vdig.qb64b)
assert issuer.getTibs(key) == []
assert issuer.cntTibs(key) == 0
assert issuer.delTibs(key) is False
assert issuer.putTibs(key, vals=[coupl01]) is True
assert issuer.getTibs(key) == [coupl01]
assert issuer.cntTibs(key) == 1
assert issuer.putTibs(key, vals=[coupl01]) is True # add duplicate
assert issuer.cntTibs(key) == 1
assert issuer.addTib(key, coupl01) is False
assert issuer.addTib(key, coupl02) is True
assert issuer.cntTibs(key) == 2
assert issuer.putTibs(key, vals=[coupl02, coupl03]) is True
assert issuer.cntTibs(key) == 3
assert issuer.delTibs(key) is True
assert issuer.getTibs(key) == []
for c in coups:
assert issuer.addTib(key, c) is True
assert issuer.cntTibs(key) == 3
assert issuer.getTibs(key) == [coupl01, coupl02, coupl03]
for c in issuer.getTibsIter(key):
assert issuer.delTibs(key, c) is True
assert issuer.getTibs(key) == []
tweKey = snKey(regk, sn)
assert issuer.getTwe(tweKey) is None
assert issuer.delTwe(tweKey) is False
assert issuer.putTwe(tweKey, val=vdig.qb64b)
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.putTwe(tweKey, val=vdig.qb64b) is False
assert issuer.setTwe(tweKey, val=vdig.qb64b) is True
assert issuer.getTwe(tweKey) == vdig.qb64b
assert issuer.delTwe(tweKey) is True
assert issuer.getTwe(tweKey) is None
ooKey = snKey(regk, sn)
assert issuer.getOot(ooKey) is None
assert issuer.delOot(ooKey) is False
assert issuer.putOot(ooKey, val=vdig.qb64b)
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.putOot(ooKey, val=vdig.qb64b) is False
assert issuer.setOot(ooKey, val=vdig.qb64b) is True
assert issuer.getOot(ooKey) == vdig.qb64b
assert issuer.delOot(ooKey) is True
assert issuer.getOot(ooKey) is None
anc01 = (
"0AAAAAAAAAAAAAAAAAAAAABA"
"Ezpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4").encode("utf-8")
key = dgKey(regk, vdig.qb64b)
assert issuer.getAnc(key) is None
assert issuer.delAnc(key) is False
assert issuer.putAnc(key, val=anc01)
assert issuer.getAnc(key) == anc01
assert issuer.putAnc(key, val=anc01) is False
assert issuer.setAnc(key, val=anc01) is True
assert issuer.getAnc(key) == anc01
assert issuer.delAnc(key) is True
assert issuer.getAnc(key) is None
# test with verifiable credential issuance (iss) event
vcdig = b'EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc'
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs, i=vcdig.decode("utf-8"), s="{:x}".format(sn), t="iss")
issb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert issb == (b'{"v":"KERI10JSON000014_",'
b'"i":"EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc",'
b''
b'"s":"0","t":"iss"}')
idig = Diger(ser=issb)
key = dgKey(vcdig, idig.qb64b)
assert issuer.getTvt(key) is None
assert issuer.delTvt(key) is False
assert issuer.putTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.putTvt(key, val=issb) is False
assert issuer.setTvt(key, val=issb) is True
assert issuer.getTvt(key) == issb
assert issuer.delTvt(key) is True
assert issuer.getTvt(key) is None
telKey = snKey(vcdig, sn)
assert issuer.getTel(telKey) is None
assert issuer.delTel(telKey) is False
assert issuer.putTel(telKey, val=idig.qb64b)
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.putTel(telKey, val=idig.qb64b) is False
assert issuer.setTel(telKey, val=idig.qb64b) is True
assert issuer.getTel(telKey) == idig.qb64b
assert issuer.delTel(telKey) is True
assert issuer.getTel(telKey) is None
rev = dict(v=vs,
i=vcdig.decode("utf-8"),
s="{:x}".format(sn + 1),
t="rev")
revb = json.dumps(rev, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
assert revb == b'{"v":"KERI10JSON000014_","i":"EXvR3p8V95W8J7Ui4-mEzZ79S-A1esAnJo1Kmzq80Jkc","s":"1","t":"rev"}'
rdig = Diger(raw=revb)
assert issuer.putTel(snKey(vcdig, sn), val=idig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 1), val=rdig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 2), val=idig.qb64b) is True
assert issuer.putTel(snKey(vcdig, sn + 3), val=rdig.qb64b) is True
result = [(sn, dig) for sn, dig in issuer.getTelItemPreIter(vcdig)]
assert result == [(0, idig.qb64b), (1, rdig.qb64b), (2, idig.qb64b),
(3, rdig.qb64b)]
bak1 = b'Bm1Q98kT0HRn9R62lY-LufjjKdbCeL1mqu9arTgOmbqI'
bak2 = b'DSEpNJeSJjxo6oAxkNE8eCOJg2HRPstqkeHWBAvN9XNU'
bak3 = b'Dvxo-P4W_Z0xXTfoA3_4DMPn7oi0mLCElOWJDpC0nQXw'
bak4 = b'BleAn9JkFuEOOwDhfkhnxtGsRQkMh2AH1oGB9QHAvl1U'
bak5 = b'Behy5f2BIJbAYdgoy00OcOEZwEyxCGCUDlzbGkbz1RAI'
baks = [bak1, bak2, bak3, bak4]
# test .baks insertion order dup methods. dup vals are insertion order
assert issuer.getBaks(key) == []
assert issuer.cntBaks(key) == 0
assert issuer.delBaks(key) is False
assert issuer.putBaks(key, baks) is True
assert issuer.getBaks(key) == baks
assert issuer.cntBaks(key) == len(baks) == 4
assert issuer.putBaks(key, vals=[bak1]) is False
assert issuer.getBaks(key) == baks
assert issuer.addBak(key, bak1) is False
assert issuer.addBak(key, bak5) is True
assert issuer.getBaks(key) == [bak1, bak2, bak3, bak4, bak5]
assert [val for val in issuer.getBaksIter(key)
] == [bak1, bak2, bak3, bak4, bak5]
assert issuer.delBaks(key) is True
assert issuer.getBaks(key) == []
"""End Test"""
def test_clone():
ipreb = "DYmJApMvMb8mgiG20BPlPcKLWSfNIUCC21DP0i2_BLjo".encode("utf-8")
regk = "EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0".encode("utf-8")
rarb = "BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA".encode("utf-8")
rarb2 = "BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4".encode("utf-8")
# test with registry inception (vcp) event
sn = 0
vs = Versify(kind=Serials.json, size=20)
vcp = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn),
b=[rarb.decode("utf-8")],
t="vcp")
vcpb = json.dumps(vcp, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
vdig = Diger(ser=vcpb)
anc01 = "0AAAAAAAAAAAAAAAAAAAAABAEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib01 = (
"BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQkg_"
"gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ").encode("utf-8")
rot1 = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn + 1),
ba=[rarb2.decode("utf-8")],
t="rot")
rot1b = json.dumps(rot1, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
r1dig = Diger(ser=rot1b)
anc02 = "0AAAAAAAAAAAAAAAAAAAAABBEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib02 = (
"BW1gbapuOJ4TJKwLfKZs5cXEIs9k8EtBqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6"
"EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw").encode("utf-8")
rot2 = dict(v=vs,
i=regk.decode("utf-8"),
s="{:x}".format(sn + 2),
br=[rarb.decode("utf-8")],
t="rot")
rot2b = json.dumps(rot2, separators=(",", ":"),
ensure_ascii=False).encode("utf-8")
r2dig = Diger(ser=rot2b)
anc03 = "0AAAAAAAAAAAAAAAAAAAAABCEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4".encode(
"utf-8")
tib03 = (
"BklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDiP"
"jioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA").encode("utf-8")
with openLMDB(cls=Registry) as issuer:
dgkey = dgKey(regk, vdig.qb64b)
snkey = snKey(regk, sn)
assert issuer.putTvt(dgkey, val=vcpb) is True
assert issuer.putTel(snkey, val=vdig.qb64b)
assert issuer.putAnc(dgkey, val=anc01) is True
assert issuer.putTibs(dgkey, vals=[tib01]) is True
dgkey = dgKey(regk, r1dig.qb64b)
snkey = snKey(regk, sn + 1)
assert issuer.putTvt(dgkey, val=rot1b) is True
assert issuer.putTel(snkey, val=r1dig.qb64b)
assert issuer.putAnc(dgkey, val=anc02) is True
assert issuer.putTibs(dgkey, vals=[tib02]) is True
dgkey = dgKey(regk, r2dig.qb64b)
snkey = snKey(regk, sn + 2)
assert issuer.putTvt(dgkey, val=rot2b) is True
assert issuer.putTel(snkey, val=r2dig.qb64b)
assert issuer.putAnc(dgkey, val=anc03) is True
assert issuer.putTibs(dgkey, vals=[tib03]) is True
msgs = bytearray() # outgoing messages
for msg in issuer.clonePreIter(regk):
msgs.extend(msg)
assert msgs == (
b'{"v":"KERI10JSON000014_","i":"EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"0",'
b'"b":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"],'
b'"t":"vcp"}-VA0-BABBPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4AAfiKvopJ0O2afOmxb5A6JtdY7Wkl_1uNx1Z8xQk'
b'g_gMzf-vTfEHDylFdgn2e_u_ppaFajIdvEvONX6dcSYzlfBQ-GAB0AAAAAAAAAAAAAAAAAAAAABAEzpq06UecHwzy-K9FpNoRxCJp2'
b'wIGM9u2Edk-PLMZ1H4{"v":"KERI10JSON000014_","i":"EOWdT7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"1",'
b'"ba":["BPVuWC4Hc0izqPKn2LIwhp72SHJSRgfaL1RhtuiavIy4"],"t":"rot"}-VA0-BABBW1gbapuOJ4TJKwLfKZs5cXEIs9k8Et'
b'BqxR1psVxnD7IABrSkjrgPGXdhBiOy6LUZpiqtsHkKHhfLGj_LhT1n6EqCIdDjrihzrdM1bm0ZNJDwbDGXoeeZujd7ZYsOsBPzRCw-G'
b'AB0AAAAAAAAAAAAAAAAAAAAABBEzpq06UecHwzy-K9FpNoRxCJp2wIGM9u2Edk-PLMZ1H4{"v":"KERI10JSON000014_","i":"EOWd'
b'T7a7fZwRz0jiZ0DJxZEM3vsNbLDPEUk-ODnif3O0","s":"2","br":["BijzaUuRMwh1ivT5BQrqNhbvx82lB-ofrHVHjL3WADbA"]'
b',"t":"rot"}-VA0-BABBklrMm7GlYzNrPQunLJHFn_1wWjlUslGkXfs0KyoNOEAAC_6PB5Zre_E_7YLkM9OtRo-uYmwRyFmOH3Xo4JDi'
b'PjioY7Ycna6ouhSSH0QcKsEjce10HCXIW_XtmEYr9SrB5BA-GAB0AAAAAAAAAAAAAAAAAAAAABCEzpq06UecHwzy-K9FpNoRxCJp2wIG'
b'M9u2Edk-PLMZ1H4')
def test_lmdber():
"""
Test LMDBer creation
"""
databaser = LMDBer()
assert isinstance(databaser, LMDBer)
assert databaser.name == "main"
assert databaser.temp == False
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.endswith("keri/db/main")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
assert databaser.opened
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
databaser.close(clear=True)
assert not os.path.exists(databaser.path)
assert not databaser.opened
# test not opened on init
databaser = LMDBer(reopen=False)
assert isinstance(databaser, LMDBer)
assert databaser.name == "main"
assert databaser.temp == False
assert databaser.opened == False
assert databaser.path == None
assert databaser.env == None
databaser.reopen()
assert databaser.opened
assert isinstance(databaser.env, lmdb.Environment)
assert databaser.path.endswith("keri/db/main")
assert databaser.env.path() == databaser.path
assert os.path.exists(databaser.path)
pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'
sn = 3
assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.00000000000000000000000000000003')
assert dgKey(pre,
dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'
b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4')
databaser.close(clear=True)
assert not os.path.exists(databaser.path)
assert not databaser.opened
with openLMDB() as dber:
assert dber.temp == True
#test Val methods
key = b'A'
val = b'whatever'
db = dber.env.open_db(key=b'beep.')
assert dber.getVal(db, key) == None
assert dber.delVal(db, key) == False
assert dber.putVal(db, key, val) == True
assert dber.putVal(db, key, val) == False
assert dber.setVal(db, key, val) == True
assert dber.getVal(db, key) == val
assert dber.delVal(db, key) == True
assert dber.getVal(db, key) == None
# Test getAllItemIter(self, db, key=b'', split=True, sep=b'.')
key = b"a.1"
val = b"wow"
assert dber.putVal(db, key, val) == True
key = b"a.2"
val = b"wee"
assert dber.putVal(db, key, val) == True
key = b"b.1"
val = b"woo"
assert dber.putVal(db, key, val) == True
assert [(bytes(pre), bytes(num), bytes(val))
for pre, num, val in dber.getAllItemIter(db=db)
] == [(b'a', b'1', b'wow'), (b'a', b'2', b'wee'),
(b'b', b'1', b'woo')]
# test OrdVal OrdItem ordinal numbered event sub db
db = dber.env.open_db(key=b'seen.')
preA = b'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc'
preB = b'EH7Oq9oxCgYa-nnNLvwhp9sFZpALILlRYyB-6n4WDi7w'
preC = b'EpDA1n-WiBA0A8YOqnKrB-wWQYYC49i5zY_qrIZIicQg'
keyA0 = onKey(preA, 0)
keyB0 = onKey(preB, 0)
keyB1 = onKey(preB, 1)
keyB2 = onKey(preB, 2)
keyB3 = onKey(preB, 3)
keyB4 = onKey(preB, 4)
keyC0 = onKey(preC, 0)
digA = b'ER73b7reENuBahMJsMTLbeyyNPsfTRzKRWtJ3ytmInvw'
digU = b'ER73b7reENuBahMJsMTLbeyyNPsfTRzKRWtJ3ytmInvw'
digV = b'EA4vCeJswIBJlO3RqE-wsE72Vt3wAceJ_LzqKvbDtBSY'
digW = b'EyAyl33W9ja_wLX85UrzRnL4KNzlsIKIA7CrD04nVX1w'
digX = b'EEnwxEm5Bg5s5aTLsgQCNpubIYzwlvMwZIzdOM0Z3u7o'
digY = b'Enrq74_Q11S2vHx1gpK_46Ik5Q7Yy9K1zZ5BavqGDKnk'
digC = b'E-5RimdY_OWoreR-Z-Q5G81-I4tjASJCaP_MqkBbtM2w'
assert dber.getVal(db, keyA0) == None
assert dber.delVal(db, keyA0) == False
assert dber.putVal(db, keyA0, val=digA) == True
assert dber.getVal(db, keyA0) == digA
assert dber.putVal(db, keyA0, val=digA) == False
assert dber.setVal(db, keyA0, val=digA) == True
assert dber.getVal(db, keyA0) == digA
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
# test appendOrdValPre
# empty database
assert dber.getVal(db, keyB0) == None
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# earlier pre in database only
assert dber.putVal(db, keyA0, val=digA) == True
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# earlier and later pre in db but not same pre
assert dber.getVal(db, keyA0) == digA
assert dber.putVal(db, keyC0, val=digC) == True
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
assert dber.delVal(db, keyB0) == True
assert dber.getVal(db, keyB0) == None
# later pre only
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
assert dber.getVal(db, keyC0) == digC
on = dber.appendOrdValPre(db, preB, digU)
assert on == 0
assert dber.getVal(db, keyB0) == digU
# earlier pre and later pre and earlier entry for same pre
assert dber.putVal(db, keyA0, val=digA) == True
on = dber.appendOrdValPre(db, preB, digV)
assert on == 1
assert dber.getVal(db, keyB1) == digV
# earlier entry for same pre but only same pre
assert dber.delVal(db, keyA0) == True
assert dber.getVal(db, keyA0) == None
assert dber.delVal(db, keyC0) == True
assert dber.getVal(db, keyC0) == None
# another value for preB
on = dber.appendOrdValPre(db, preB, digW)
assert on == 2
assert dber.getVal(db, keyB2) == digW
# yet another value for preB
on = dber.appendOrdValPre(db, preB, digX)
assert on == 3
assert dber.getVal(db, keyB3) == digX
# yet another value for preB
on = dber.appendOrdValPre(db, preB, digY)
assert on == 4
assert dber.getVal(db, keyB4) == digY
assert dber.cntValsAllPre(db, preB) == 5
# replay preB events in database
items = [item for item in dber.getAllOrdItemPreIter(db, preB)]
assert items == [(0, digU), (1, digV), (2, digW), (3, digX), (4, digY)]
# resume replay preB events at on = 3
items = [item for item in dber.getAllOrdItemPreIter(db, preB, on=3)]
assert items == [(3, digX), (4, digY)]
# resume replay preB events at on = 5
items = [item for item in dber.getAllOrdItemPreIter(db, preB, on=5)]
assert items == []
# replay all events in database with pre events before and after
assert dber.putVal(db, keyA0, val=digA) == True
assert dber.putVal(db, keyC0, val=digC) == True
items = [item for item in dber.getAllOrdItemAllPreIter(db)]
assert items == [(preA, 0, digA), (preB, 0, digU), (preB, 1, digV),
(preB, 2, digW), (preB, 3, digX), (preB, 4, digY),
(preC, 0, digC)]
# resume replay all starting at preB on=2
items = [item for item in dber.getAllOrdItemAllPreIter(db, key=keyB2)]
assert items == [(preB, 2, digW), (preB, 3, digX), (preB, 4, digY),
(preC, 0, digC)]
# resume replay all starting at preC on=1
items = [
item
for item in dber.getAllOrdItemAllPreIter(db, key=onKey(preC, 1))
]
assert items == []
# test Vals dup methods. dup vals are lexocographic
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'boop.', dupsort=True)
assert dber.getVals(db, key) == []
assert dber.delVals(db, key) == False
assert dber.cntVals(db, key) == 0
assert dber.putVals(db, key, vals) == True
assert dber.getVals(db, key) == [b'a', b'm', b'x',
b'z'] # lexocographic order
assert dber.cntVals(db, key) == len(vals) == 4
assert dber.putVals(db, key, vals=[b'a']) == True # duplicate
assert dber.getVals(db, key) == [b'a', b'm', b'x', b'z'] # no change
assert dber.addVal(db, key, val=b'a') == False # duplicate
assert dber.addVal(db, key, val=b'b') == True
assert dber.getVals(db, key) == [b'a', b'b', b'm', b'x', b'z']
assert [val for val in dber.getValsIter(db, key)
] == [b'a', b'b', b'm', b'x', b'z']
assert dber.delVals(db, key) == True
assert dber.getVals(db, key) == []
assert dber.putVals(db, key, vals) == True
for val in vals:
assert dber.delVals(db, key, val)
assert dber.getVals(db, key) == []
assert dber.putVals(db, key, vals) == True
for val in dber.getValsIter(db, key):
assert dber.delVals(
db, key, val) # allows delete fo dup while iter over dups
assert dber.getVals(db, key) == []
# test IoVals insertion order dup methods. dup vals are insertion order
key = b'A'
vals = [b"z", b"m", b"x", b"a"]
db = dber.env.open_db(key=b'peep.', dupsort=True)
assert dber.getIoVals(db, key) == []
assert dber.getIoValLast(db, key) == None
assert dber.cntIoVals(db, key) == 0
assert dber.delIoVals(db, key) == False
assert dber.putIoVals(db, key, vals) == True
assert dber.getIoVals(db, key) == vals # preserved insertion order
assert dber.cntIoVals(db, key) == len(vals) == 4
assert dber.getIoValLast(db, key) == vals[-1]
assert dber.putIoVals(db, key, vals=[b'a']) == False # duplicate
assert dber.getIoVals(db, key) == vals # no change
assert dber.addIoVal(db, key, val=b'b') == True
assert dber.addIoVal(db, key, val=b'a') == False
assert dber.getIoVals(db, key) == [b"z", b"m", b"x", b"a", b"b"]
assert [val for val in dber.getIoValsIter(db, key)
] == [b"z", b"m", b"x", b"a", b'b']
assert dber.delIoVals(db, key) == True
assert dber.getIoVals(db, key) == []
assert dber.putIoVals(db, key, vals) == True
for val in vals:
assert dber.delIoVal(db, key, val)
assert dber.getIoVals(db, key) == []
assert dber.putIoVals(db, key, vals) == True
for val in sorted(vals):
assert dber.delIoVal(db, key, val)
assert dber.getIoVals(db, key) == []
#delete and add in odd order
assert dber.putIoVals(db, key, vals) == True
assert dber.delIoVal(db, key, vals[2])
assert dber.addIoVal(db, key, b'w')
assert dber.delIoVal(db, key, vals[0])
assert dber.addIoVal(db, key, b'e')
assert dber.getIoVals(db, key) == [b'm', b'a', b'w', b'e']
# Test getIoValsAllPreIter(self, db, pre)
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAllPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
# Test getIoValsLastAllPreIter(self, db, pre)
pre = b'B4ejWzwQPYGGwTmuupUhPx5_yZ-Wk1xEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 0
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValLastAllPreIter(db, pre)]
lastvals = [vals0[-1], vals1[-1], vals2[-1]]
assert vals == lastvals
# Test getIoValsAnyPreIter(self, db, pre)
pre = b'BQPYGGwTmuupUhPx5_yZ-Wk1x4ejWzwEHHzq7K0gzhcc'
vals0 = [b"gamma", b"beta"]
sn = 1 # not start at zero
key = snKey(pre, sn)
assert dber.addIoVal(db, key, vals0[0]) == True
assert dber.addIoVal(db, key, vals0[1]) == True
vals1 = [b"mary", b"peter", b"john", b"paul"]
sn += 1
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals1) == True
vals2 = [b"dog", b"cat", b"bird"]
sn += 2 # gap
key = snKey(pre, sn)
assert dber.putIoVals(db, key, vals2) == True
vals = [bytes(val) for val in dber.getIoValsAnyPreIter(db, pre)]
allvals = vals0 + vals1 + vals2
assert vals == allvals
# Setup Tests for getIoItemsNext and getIoItemsNextIter
edb = dber.env.open_db(key=b'escrow.', dupsort=True)
aKey = snKey(pre=b'A', sn=1)
aVals = [b"z", b"m", b"x"]
bKey = snKey(pre=b'A', sn=2)
bVals = [b"o", b"r", b"z"]
cKey = snKey(pre=b'A', sn=4)
cVals = [b"h", b"n"]
dKey = snKey(pre=b'A', sn=7)
dVals = [b"k", b"b"]
assert dber.putIoVals(edb, key=aKey, vals=aVals)
assert dber.putIoVals(edb, key=bKey, vals=bVals)
assert dber.putIoVals(edb, key=cKey, vals=cVals)
assert dber.putIoVals(edb, key=dKey, vals=dVals)
# Test getIoItemsNext(self, db, key=b"")
# aVals
items = dber.getIoItemsNext(edb) # get first key in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = dber.getIoItemsNext(edb, key=aKey,
skip=False) # get aKey in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = dber.getIoItemsNext(edb, key=aKey) # get bKey in database
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
items = dber.getIoItemsNext(edb, key=b'',
skip=False) # get first key in database
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
# bVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
# cVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == cKey
vals = [val for key, val in items]
assert vals == cVals
# dVals
items = dber.getIoItemsNext(edb, key=ikey)
assert items # not empty
ikey = items[0][0]
assert ikey == dKey
vals = [val for key, val in items]
assert vals == dVals
# none
items = dber.getIoItemsNext(edb, key=ikey)
assert items == [] # empty
assert not items
# Test getIoItemsNextIter(self, db, key=b"")
# get dups at first key in database
# aVals
items = [item for item in dber.getIoItemsNextIter(edb)]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = [
item for item in dber.getIoItemsNextIter(edb, key=aKey, skip=False)
]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
items = [item for item in dber.getIoItemsNextIter(edb, key=aKey)]
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
items = [
item for item in dber.getIoItemsNextIter(edb, key=b'', skip=False)
]
assert items # not empty
ikey = items[0][0]
assert ikey == aKey
vals = [val for key, val in items]
assert vals == aVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# bVals
items = [item for item in dber.getIoItemsNextIter(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == bKey
vals = [val for key, val in items]
assert vals == bVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# cVals
items = [item for item in dber.getIoItemsNextIter(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == cKey
vals = [val for key, val in items]
assert vals == cVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# dVals
items = [item for item in dber.getIoItemsNext(edb, key=ikey)]
assert items # not empty
ikey = items[0][0]
assert ikey == dKey
vals = [val for key, val in items]
assert vals == dVals
for key, val in items:
assert dber.delIoVal(edb, ikey, val) == True
# none
items = [item for item in dber.getIoItemsNext(edb, key=ikey)]
assert items == [] # empty
assert not items
assert not os.path.exists(dber.path)
""" End Test """
def test_happy_path():
"""
Test Komer object class
"""
@dataclass
class Record:
first: str # first name
last: str # last name
street: str # street address
city: str # city name
state: str # state code
zip: int # zip code
def __iter__(self):
return iter(asdict(self))
jim = Record(first="Jim",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
jimser = json.dumps(asdict(jim)).encode("utf-8")
jim = helping.datify(Record, json.loads(bytes(jimser).decode("utf-8")))
assert isinstance(jim, Record)
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
mydb = basing.Komer(db=db, schema=Record, subdb='records.')
assert isinstance(mydb, basing.Komer)
sue = Record(first="Susan",
last="Black",
street="100 Main Street",
city="Riverton",
state="UT",
zip=84058)
keys = ("test_key", "0001")
mydb.put(keys=keys, data=sue)
actual = mydb.get(keys=keys)
assert actual.first == "Susan"
assert actual.last == "Black"
assert actual.street == "100 Main Street"
assert actual.city == "Riverton"
assert actual.state == "UT"
assert actual.zip == 84058
mydb.rem(keys)
actual = mydb.get(keys=keys)
assert actual is None
assert not os.path.exists(db.path)
assert not db.opened
