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