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_key_funcs(): """ Test key utility functions """ # Bytes pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4' sn = 3 dts = b'2021-02-13T19:16:50.750302+00:00' assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'.00000000000000000000000000000003') assert splitKey(snKey(pre, sn)) == (pre, b'%032x' % sn) assert splitKeySN(snKey(pre, sn)) == (pre, sn) assert dgKey(pre, dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4') assert splitKey(dgKey(pre, dig)) == (pre, dig) assert dtKey(pre, dts) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'|2021-02-13T19:16:50.750302+00:00') assert splitKey(dtKey(pre, dts), sep=b'|') == (pre, dts) assert splitKeyDT(dtKey(pre, dts)) == (pre, helping.fromIso8601(dts.decode("utf-8"))) # Str pre = 'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' dig = 'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4' dts = '2021-02-13T19:16:50.750302+00:00' assert snKey(pre, sn) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'.00000000000000000000000000000003') assert splitKey(snKey(pre, sn).decode("utf-8")) == (pre, '%032x' % sn) assert splitKeySN(snKey(pre, sn).decode("utf-8")) == (pre, sn) assert dgKey(pre, dig) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'.EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4') assert splitKey(dgKey(pre, dig).decode("utf-8")) == (pre, dig) assert dtKey(pre, dts) == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' b'|2021-02-13T19:16:50.750302+00:00') assert splitKey(dtKey(pre, dts).decode("utf-8"), sep=b'|') == (pre, dts) assert splitKeyDT(dtKey(pre, dts).decode("utf-8")) == (pre, helping.fromIso8601(dts)) with pytest.raises(TypeError): snKey(pre, sn='3') with pytest.raises(ValueError): splitKey(pre) with pytest.raises(ValueError): splitKey(dgKey(pre, dgKey(pre, dig))) # memoryview # Bytes pre = b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc' dig = b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4' sn = 3 dts = b'2021-02-13T19:16:50.750302+00:00' key = memoryview(snKey(pre, sn)) assert splitKey(key) == (pre, b'%032x' % sn) assert splitKeySN(key) == (pre, sn) key = memoryview(dgKey(pre, dig)) assert splitKey(key) == (pre, dig) key = memoryview(dtKey(pre, dts)) assert splitKey(key, sep=b'|') == (pre, dts) assert splitKeyDT(key) == (pre, helping.fromIso8601(dts.decode("utf-8"))) """Done Test"""
def test_direct_mode_with_manager(): """ Test direct mode with transferable validator event receipts """ # manual process to generate a list of secrets # root = pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES) # secrets = generateSecrets(root=root, count=8) # Direct Mode initiated by coe is controller, val is validator # but goes both ways once initiated. # set of secrets (seeds for private keys) coeSalt = Salter(raw=b'0123456789abcdea').qb64 # set of secrets (seeds for private keys) valSalt = Salter(raw=b'1123456789abcdea').qb64 with openDB("controller") as coeLogger, openDB("validator") as valLogger, \ openKS(name="controller") as coeKpr, openKS(name="validator") as valKpr: # Init key pair manager coeMgr = Manager(keeper=coeKpr, salt=coeSalt) coeVerfers, coeDigers, cst, nst = coeMgr.incept(icount=1, ncount=1) # init Keverys coeKevery = eventing.Kevery(db=coeLogger) valKevery = eventing.Kevery(db=valLogger) coe_event_digs = [] # list of controller's own event log digs to verify against database val_event_digs = [] # list of validator's own event log digs to verify against database # init sequence numbers for both controller and validator csn = cesn = 0 # sn and last establishment sn = esn vsn = vesn = 0 # sn and last establishment sn = esn # Controller Event 0 Inception Transferable (nxt digest not empty) coeSerder = incept(keys=[coeVerfers[0].qb64], nxt=eventing.Nexter(digs=[coeDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert csn == int(coeSerder.ked["s"], 16) == 0 coepre = coeSerder.ked["i"] coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(ser=coeSerder.raw, verfers=coeVerfers) # create serialized message cmsg = messagize(coeSerder, sigers=sigers) # create own Controller Kever in Controller's Kevery parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # coeKevery.processOne(ims=bytearray(cmsg)) # send copy of cmsg coeKever = coeKevery.kevers[coepre] assert coeKever.prefixer.qb64 == coepre # Validator Event 0 Inception Transferable (nxt digest not empty) # Init key pair manager valMgr = Manager(keeper=valKpr, salt=valSalt) valVerfers, valDigers, cst, nst = valMgr.incept(icount=1, ncount=1) valSerder = incept(keys=[valVerfers[0].qb64], nxt=eventing.Nexter(digs=[valDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert vsn == int(valSerder.ked["s"], 16) == 0 valpre = valSerder.ked["i"] val_event_digs.append(valSerder.dig) # sign serialization sigers = valMgr.sign(valSerder.raw, verfers=valVerfers) # return Siger if index # create serialized message vmsg = messagize(valSerder, sigers=sigers) # create own Validator Kever in Validator's Kevery parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(vmsg)) # send copy of vmsg valKever = valKevery.kevers[valpre] assert valKever.prefixer.qb64 == valpre # simulate sending of controller's inception message to validator parsing.Parser().parse(ims=bytearray(cmsg), kvy=valKevery) # valKevery.process(ims=bytearray(cmsg)) # make copy of msg assert coepre in valKevery.kevers # creates Kever for controller in validator's .kevers # create receipt of controller's inception # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) coeK = valKevery.kevers[coepre] # lookup coeKever from validator's .kevers # create trans receipt reserder = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) #reserder = chit(pre=coeK.prefixer.qb64, #sn=coeK.sn, #dig=coeK.serder.diger.qb64, #seal=seal) # Validate receipt # sign controller's event not receipt # look up event to sign from validator's kever for coe coeIcpDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIcpDig == coeK.serder.diger.qb64b coeIcpRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIcpDig))) #counter = Counter(CtrDex.ControllerIdxSigs) #assert counter.qb64 == '-AAB' sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # process own validator receipt in validator's Kevery so have copy in own log rmsg = messagize(reserder, sigers=sigers, seal=seal) assert len(rmsg) == 353 parsing.Parser().parseOne(ims=bytearray(rmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(rmsg)) # process copy of rmsg # attach receipt message to existing message with validators inception message # simulate streaming. validator first sends it's inception event, then sends a receipt to controller vmsg.extend(rmsg) # Simulate sending validator's inception event and receipt of # controller's inception message to controller parsing.Parser().parse(ims=vmsg, kvy=coeKevery) # coeKevery.process(ims=vmsg) # controller process validator's inception and receipt # check if validator's Kever in controller's .kevers assert valpre in coeKevery.kevers # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # create receipt to escrow use invalid digest and sequence number so not in controller's db fake = reserder.dig # some other digest reserder = receipt(pre=coeK.prefixer.qb64, sn=10, dig=fake) # sign event not receipt sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # create receipt message vmsg = messagize(reserder, sigers=sigers, seal=seal) parsing.Parser().parse(ims=bytearray(vmsg), kvy=coeKevery) # coeKevery.process(ims=vmsg) # controller process the escrow receipt from validator # check if receipt quadruple in escrow database result = coeKevery.db.getVres(key=snKey(pre=coeKever.prefixer.qb64, sn=10)) assert bytes(result[0]) == (fake.encode("utf-8") + valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Send receipt from controller to validator # create receipt of validator's inception # create seal of controller's last establishment event seal = SealEvent(i=coepre, s="{:x}".format(coeKever.lastEst.s), d=coeKever.lastEst.d) valK = coeKevery.kevers[valpre] # lookup valKever from controller's .kevers # create trans receipt reserder = receipt(pre=valK.prefixer.qb64, sn=valK.sn, dig=valK.serder.diger.qb64,) # sign validator's event not receipt # look up event to sign from controller's kever for validator valIcpDig = bytes(coeKevery.db.getKeLast(key=snKey(pre=valpre, sn=vsn))) assert valIcpDig == valK.serder.diger.qb64b valIcpRaw = bytes(coeKevery.db.getEvt(key=dgKey(pre=valpre, dig=valIcpDig))) sigers = coeMgr.sign(ser=valIcpRaw, verfers=coeVerfers) # return Siger if index # create receipt message cmsg = messagize(reserder, sigers=sigers, seal=seal) # controller process own receipt in own Kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # coeKevery.processOne(ims=bytearray(cmsg)) # make copy # Simulate sending controller's receipt of validator's inception message to validator parsing.Parser().parse(ims=cmsg, kvy=valKevery) # valKevery.process(ims=cmsg) # controller process validator's inception and receipt # check if receipt quadruple from controller in validator's receipt database result = valKevery.db.getVrcs(key=dgKey(pre=valKever.prefixer.qb64, dig=valKever.serder.diger.qb64)) assert bytes(result[0]) == (coeKever.prefixer.qb64b + Seqner(sn=coeKever.sn).qb64b + coeKever.serder.diger.qb64b + sigers[0].qb64b) # Controller Event 1 Rotation Transferable csn += 1 cesn += 1 assert csn == cesn == 1 coeVerfers, coeDigers, cst, nst = coeMgr.rotate(pre=coeVerfers[0].qb64) coeSerder = rotate(pre=coeKever.prefixer.qb64, keys=[coeVerfers[0].qb64], dig=coeKever.serder.diger.qb64, nxt=eventing.Nexter(digs=[coeDigers[0].qb64]).qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # returns sigers # create serialized message cmsg = messagize(coeSerder, sigers=sigers) # update controller's key event verifier state parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator parsing.Parser().parse(ims=cmsg, kvy=valKevery) # valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's rotation # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeRotDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeRotDig == coeK.serder.diger.qb64b coeRotRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeRotDig))) sigers = valMgr.sign(ser=coeRotRaw, verfers=valVerfers) # validator create receipt message vmsg = messagize(reserder, sigers=sigers, seal=seal) # validator process own receipt in own kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message parsing.Parser().parse(ims=vmsg, kvy=coeKevery) # coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Next Event 2 Controller Interaction csn += 1 # do not increment esn assert csn == 2 assert cesn == 1 coeSerder = interact(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # create msg cmsg = messagize(coeSerder, sigers=sigers) # update controller's key event verifier state parsing.Parser().parseOne(ims=bytearray(cmsg), kvy=coeKevery) # coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator parsing.Parser().parse(ims=cmsg, kvy=valKevery) # valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's interaction # create seal of validator's last est event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = receipt(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeIxnDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIxnDig == coeK.serder.diger.qb64b coeIxnRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIxnDig))) sigers = valMgr.sign(ser=coeIxnRaw, verfers=valVerfers) # create receipt message vmsg = messagize(reserder, sigers=sigers, seal=seal) # validator process own receipt in own kevery so have copy in own log parsing.Parser().parseOne(ims=bytearray(vmsg), kvy=valKevery) # valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message parsing.Parser().parse(ims=bytearray(vmsg), kvy=coeKevery) # coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # verify final controller event state assert coeKever.sn == coeK.sn == csn db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs # verify final validator event state assert valKever.sn == valK.sn == vsn db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs assert not os.path.exists(valKevery.db.path) assert not os.path.exists(coeKever.baser.path)
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_fetchkeldel(): """ Test fetching full KEL and full DEL from Logger """ # Test using context manager preb = 'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'.encode("utf-8") digb = 'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'.encode("utf-8") sn = 3 vs = Versify(kind=Serials.json, size=20) assert vs == 'KERI10JSON000014_' ked = dict(vs=vs, pre=preb.decode("utf-8"), sn="{:x}".format(sn), ilk="rot", dig=digb.decode("utf-8")) skedb = json.dumps(ked, separators=(",", ":"), ensure_ascii=False).encode("utf-8") assert skedb == ( b'{"vs":"KERI10JSON000014_","pre":"BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhc' b'c","sn":"3","ilk":"rot","dig":"EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4"' b'}') sig0b = 'AAz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQ'.encode( "utf-8") sig1b = 'AB_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z'.encode( "utf-8") wit0b = 'BmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gzQPYGGwT'.encode("utf-8") wit1b = 'BjhccWzwEHHzq7K0gzmuupUhPx5_yZ-Wk1x4eQPYGGwT'.encode("utf-8") wsig0b = '0A1Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ9'.encode( "utf-8") wsig1b = '0A5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5Az_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2zJ91Timrykocna6Z'.encode( "utf-8") with openLogger() as lgr: # test getKelIter sn = 0 key = snKey(preb, sn) assert key == (b'BWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.' b'00000000000000000000000000000000') vals0 = [skedb] assert lgr.addKe(key, vals0[0]) == True vals1 = [b"mary", b"peter", b"john", b"paul"] sn += 1 key = snKey(preb, sn) for val in vals1: assert lgr.addKe(key, val) == True vals2 = [b"dog", b"cat", b"bird"] sn += 1 key = snKey(preb, sn) for val in vals2: assert lgr.addKe(key, val) == True vals = [bytes(val) for val in lgr.getKelIter(preb)] allvals = vals0 + vals1 + vals2 assert vals == allvals # test getKelEstIter preb = 'B4ejhccWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x'.encode("utf-8") sn = 0 key = snKey(preb, sn) assert key == (b'B4ejhccWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x.' b'00000000000000000000000000000000') vals0 = [skedb] assert lgr.addKe(key, vals0[0]) == True vals1 = [b"mary", b"peter", b"john", b"paul"] sn += 1 key = snKey(preb, sn) for val in vals1: assert lgr.addKe(key, val) == True vals2 = [b"dog", b"cat", b"bird"] sn += 1 key = snKey(preb, sn) for val in vals2: assert lgr.addKe(key, val) == True vals = [bytes(val) for val in lgr.getKelEstIter(preb)] lastvals = [vals0[-1], vals1[-1], vals2[-1]] assert vals == lastvals # test getDelIter preb = 'BTmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gzQPYGGw'.encode("utf-8") sn = 1 # do not start at zero key = snKey(preb, sn) assert key == (b'BTmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gzQPYGGw.' b'00000000000000000000000000000001') vals0 = [skedb] assert lgr.addDe(key, vals0[0]) == True vals1 = [b"mary", b"peter", b"john", b"paul"] sn += 1 key = snKey(preb, sn) for val in vals1: assert lgr.addDe(key, val) == True vals2 = [b"dog", b"cat", b"bird"] sn += 3 # skip make gap in SN key = snKey(preb, sn) for val in vals2: assert lgr.addDe(key, val) == True vals = [bytes(val) for val in lgr.getDelIter(preb)] allvals = vals0 + vals1 + vals2 assert vals == allvals assert not os.path.exists(lgr.path) """ End Test """
def test_databaser(): """ Test Databaser creation """ databaser = Databaser() assert isinstance(databaser, Databaser) assert databaser.name == "main" 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.clearDirPath() assert not os.path.exists(databaser.path) with openDatabaser() as dber: #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 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) == [] # 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.getIoValsLast(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.getIoValsLast(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 dber.delIoVals(db, key) == True assert dber.getIoVals(db, key) == [] # 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.getIoValsLastAllPreIter(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 assert not os.path.exists(dber.path) """ 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_logger(): """ Test Logger class """ logger = Logger() assert isinstance(logger, Logger) assert logger.name == "main" assert isinstance(logger.env, lmdb.Environment) assert logger.path.endswith("keri/db/main") assert logger.env.path() == logger.path assert os.path.exists(logger.path) assert isinstance(logger.evts, lmdb._Database) assert isinstance(logger.sigs, lmdb._Database) assert isinstance(logger.dtss, lmdb._Database) assert isinstance(logger.rcts, lmdb._Database) assert isinstance(logger.ures, lmdb._Database) assert isinstance(logger.kels, lmdb._Database) assert isinstance(logger.ooes, lmdb._Database) assert isinstance(logger.pses, lmdb._Database) assert isinstance(logger.dels, lmdb._Database) assert isinstance(logger.ldes, lmdb._Database) logger.clearDirPath() assert not os.path.exists(logger.path) # Test using context manager with openDatabaser(cls=Logger) as logger: assert isinstance(logger, Logger) assert logger.name == "test" assert isinstance(logger.env, lmdb.Environment) assert logger.path.startswith("/tmp/keri_lmdb_") assert logger.path.endswith("_test/keri/db/test") assert logger.env.path() == logger.path assert os.path.exists(logger.path) assert isinstance(logger.evts, lmdb._Database) assert isinstance(logger.sigs, lmdb._Database) assert isinstance(logger.dtss, lmdb._Database) assert isinstance(logger.rcts, lmdb._Database) assert isinstance(logger.ures, lmdb._Database) assert isinstance(logger.kels, lmdb._Database) assert isinstance(logger.ooes, lmdb._Database) assert isinstance(logger.pses, lmdb._Database) assert isinstance(logger.dels, lmdb._Database) assert isinstance(logger.ldes, lmdb._Database) assert not os.path.exists(logger.path) preb = 'DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc'.encode("utf-8") digb = 'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4'.encode("utf-8") sn = 3 vs = Versify(kind=Serials.json, size=20) assert vs == 'KERI10JSON000014_' ked = dict(vs=vs, pre=preb.decode("utf-8"), sn="{:x}".format(sn), ilk="rot", dig=digb.decode("utf-8")) skedb = json.dumps(ked, separators=(",", ":"), ensure_ascii=False).encode("utf-8") assert skedb == ( b'{"vs":"KERI10JSON000014_","pre":"DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhc' b'c","sn":"3","ilk":"rot","dig":"EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4"' b'}') sig0b = 'AAz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQ'.encode( "utf-8") sig1b = 'AB_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ91Timrykocna6Z'.encode( "utf-8") wit0b = 'BmuupUhPx5_yZ-Wk1x4ejhccWzwEHHzq7K0gzQPYGGwT'.encode("utf-8") wit1b = 'BjhccWzwEHHzq7K0gzmuupUhPx5_yZ-Wk1x4eQPYGGwT'.encode("utf-8") wsig0b = '0B1Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5AzJ9'.encode( "utf-8") wsig1b = '0B5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5Az_pQBl2gt59I_F6BsSwFbIOG1TDQz1KAV2zJ91Timrykocna6Z'.encode( "utf-8") valb = 'EHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhccWzwEH'.encode("utf-8") vdigb = 'EQiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4GAPkzNZMtX-'.encode("utf-8") vsig0b = 'AAKAV2z5IRqcFe4gPs9l3wsFKi1NsSZvBe81Timrykocna6Z_pQBl2gt59I_F6BsSwFbIOG1TDQz1yQJmiu5AzJ9'.encode( "utf-8") vsig1b = 'AB1KAV2zJ91Timrykocna6Z5IRqcFe4gPs9l3wsFKi1NsSZvBe8yQJmiu5Az_pQBl2gt59I_F6BsSwFbIOG1TDQz'.encode( "utf-8") with openLogger() as lgr: key = dgKey(preb, digb) assert key == (b'DWzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc.' b'EGAPkzNZMtX-QiVgbRbyAIZGoXvbGv9IPb0foWTZvI_4') # test .evts sub db methods assert lgr.getEvt(key) == None assert lgr.delEvt(key) == False assert lgr.putEvt(key, val=skedb) == True assert lgr.getEvt(key) == skedb assert lgr.putEvt(key, val=skedb) == False assert lgr.setEvt(key, val=skedb) == True assert lgr.getEvt(key) == skedb assert lgr.delEvt(key) == True assert lgr.getEvt(key) == None # test .dtss sub db methods val1 = b'2020-08-22T17:50:09.988921+00:00' val2 = b'2020-08-22T17:50:09.988921+00:00' assert lgr.getDts(key) == None assert lgr.delDts(key) == False assert lgr.putDts(key, val1) == True assert lgr.getDts(key) == val1 assert lgr.putDts(key, val2) == False assert lgr.getDts(key) == val1 assert lgr.setDts(key, val2) == True assert lgr.getDts(key) == val2 assert lgr.delDts(key) == True assert lgr.getDts(key) == None # test .sigs sub db methods assert lgr.getSigs(key) == [] assert lgr.cntSigs(key) == 0 assert lgr.delSigs(key) == False # dup vals are lexocographic assert lgr.putSigs(key, vals=[b"z", b"m", b"x", b"a"]) == True assert lgr.getSigs(key) == [b'a', b'm', b'x', b'z'] assert lgr.cntSigs(key) == 4 assert lgr.putSigs(key, vals=[b'a']) == True # duplicate but True assert lgr.getSigs(key) == [b'a', b'm', b'x', b'z'] assert lgr.addSig(key, b'a') == False # duplicate assert lgr.addSig(key, b'b') == True assert lgr.getSigs(key) == [b'a', b'b', b'm', b'x', b'z'] assert [val for val in lgr.getSigsIter(key) ] == [b'a', b'b', b'm', b'x', b'z'] assert lgr.delSigs(key) == True assert lgr.getSigs(key) == [] assert lgr.putSigs(key, vals=[sig0b]) == True assert lgr.getSigs(key) == [sig0b] assert lgr.putSigs(key, vals=[sig1b]) == True assert lgr.getSigs(key) == [sig0b, sig1b] assert lgr.delSigs(key) == True assert lgr.putSigs(key, vals=[sig1b, sig0b]) == True assert lgr.getSigs(key) == [sig0b, sig1b] assert lgr.delSigs(key) == True assert lgr.getSigs(key) == [] # test .rcts sub db methods dgkey assert lgr.getRcts(key) == [] assert lgr.cntRcts(key) == 0 assert lgr.delRcts(key) == False # dup vals are lexocographic assert lgr.putRcts(key, vals=[b"z", b"m", b"x", b"a"]) == True assert lgr.getRcts(key) == [b'a', b'm', b'x', b'z'] assert lgr.cntRcts(key) == 4 assert lgr.putRcts(key, vals=[b'a']) == True # duplicate assert lgr.getRcts(key) == [b'a', b'm', b'x', b'z'] assert lgr.addRct(key, b'a') == False # duplicate assert lgr.addRct(key, b'b') == True assert lgr.getRcts(key) == [b'a', b'b', b'm', b'x', b'z'] assert [val for val in lgr.getRctsIter(key) ] == [b'a', b'b', b'm', b'x', b'z'] assert lgr.delRcts(key) == True assert lgr.getRcts(key) == [] assert lgr.putRcts(key, vals=[wit0b + wsig0b, wit1b + wsig1b]) == True assert lgr.getRcts(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.putRcts(key, vals=[wit1b + wsig1b]) == True assert lgr.getRcts(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.delRcts(key) == True assert lgr.putRcts(key, vals=[wit1b + wsig1b, wit0b + wsig0b]) == True assert lgr.getRcts(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.delRcts(key) == True assert lgr.getRcts(key) == [] # test .ures sub db methods dgKey assert lgr.getUres(key) == [] assert lgr.cntUres(key) == 0 assert lgr.delUres(key) == False # dup vals are lexocographic assert lgr.putUres(key, vals=[b"z", b"m", b"x", b"a"]) == True assert lgr.getUres(key) == [b'a', b'm', b'x', b'z'] assert lgr.cntUres(key) == 4 assert lgr.putUres(key, vals=[b'a']) == True # duplicate assert lgr.getUres(key) == [b'a', b'm', b'x', b'z'] assert lgr.addUre(key, b'a') == False # duplicate assert lgr.addUre(key, b'b') == True assert lgr.getUres(key) == [b'a', b'b', b'm', b'x', b'z'] assert [val for val in lgr.getUresIter(key) ] == [b'a', b'b', b'm', b'x', b'z'] assert lgr.delUres(key) == True assert lgr.getUres(key) == [] assert lgr.putUres(key, vals=[wit0b + wsig0b, wit1b + wsig1b]) == True assert lgr.getUres(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.putUres(key, vals=[wit1b + wsig1b]) == True assert lgr.getUres(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.delUres(key) == True assert lgr.putUres(key, vals=[wit1b + wsig1b, wit0b + wsig0b]) == True assert lgr.getUres(key) == [wit1b + wsig1b, wit0b + wsig0b] # lex order assert lgr.delUres(key) == True assert lgr.getUres(key) == [] # test .vrcs sub db methods dgkey assert lgr.getVrcs(key) == [] assert lgr.cntVrcs(key) == 0 assert lgr.delVrcs(key) == False # dup vals are lexocographic assert lgr.putVrcs(key, vals=[b"z", b"m", b"x", b"a"]) == True assert lgr.getVrcs(key) == [b'a', b'm', b'x', b'z'] assert lgr.cntVrcs(key) == 4 assert lgr.putVrcs(key, vals=[b'a']) == True # duplicate assert lgr.getVrcs(key) == [b'a', b'm', b'x', b'z'] assert lgr.addVrc(key, b'a') == False # duplicate assert lgr.addVrc(key, b'b') == True assert lgr.getVrcs(key) == [b'a', b'b', b'm', b'x', b'z'] assert [val for val in lgr.getVrcsIter(key) ] == [b'a', b'b', b'm', b'x', b'z'] assert lgr.delVrcs(key) == True assert lgr.getVrcs(key) == [] assert lgr.putVrcs(key, vals=[valb + vdigb + vsig0b, valb + vdigb + vsig1b]) == True assert lgr.getVrcs(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.putVrcs(key, vals=[valb + vdigb + vsig1b]) == True assert lgr.getVrcs(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.delVrcs(key) == True assert lgr.putVrcs(key, vals=[valb + vdigb + vsig1b, valb + vdigb + vsig0b]) == True assert lgr.getVrcs(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.delVrcs(key) == True assert lgr.getVrcs(key) == [] # test .vres sub db methods dgKey assert lgr.getVres(key) == [] assert lgr.cntVres(key) == 0 assert lgr.delVres(key) == False # dup vals are lexocographic assert lgr.putVres(key, vals=[b"z", b"m", b"x", b"a"]) == True assert lgr.getVres(key) == [b'a', b'm', b'x', b'z'] assert lgr.cntVres(key) == 4 assert lgr.putVres(key, vals=[b'a']) == True # duplicate assert lgr.getVres(key) == [b'a', b'm', b'x', b'z'] assert lgr.addVre(key, b'a') == False # duplicate assert lgr.addVre(key, b'b') == True assert lgr.getVres(key) == [b'a', b'b', b'm', b'x', b'z'] assert [val for val in lgr.getVresIter(key) ] == [b'a', b'b', b'm', b'x', b'z'] assert lgr.delVres(key) == True assert lgr.getVres(key) == [] assert lgr.putVres(key, vals=[valb + vdigb + vsig0b, valb + vdigb + vsig1b]) == True assert lgr.getVres(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.putVres(key, vals=[valb + vdigb + vsig1b]) == True assert lgr.getVres(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.delVres(key) == True assert lgr.putVres(key, vals=[valb + vdigb + vsig1b, valb + vdigb + vsig0b]) == True assert lgr.getVres(key) == [ valb + vdigb + vsig0b, valb + vdigb + vsig1b ] # lex order assert lgr.delVres(key) == True assert lgr.getVres(key) == [] # test .kels insertion order dup methods. dup vals are insertion order key = snKey(preb, 0) vals = [b"z", b"m", b"x", b"a"] assert lgr.getKes(key) == [] assert lgr.getKeLast(key) == None assert lgr.cntKes(key) == 0 assert lgr.delKes(key) == False assert lgr.putKes(key, vals) == True assert lgr.getKes(key) == vals # preserved insertion order assert lgr.cntKes(key) == len(vals) == 4 assert lgr.getKeLast(key) == vals[-1] assert lgr.putKes(key, vals=[b'a']) == False # duplicate assert lgr.getKes(key) == vals # no change assert lgr.addKe(key, b'a') == False # duplicate assert lgr.addKe(key, b'b') == True assert lgr.getKes(key) == [b"z", b"m", b"x", b"a", b"b"] assert lgr.delKes(key) == True assert lgr.getKes(key) == [] # test .pses insertion order dup methods. dup vals are insertion order key = b'A' vals = [b"z", b"m", b"x", b"a"] assert lgr.getPses(key) == [] assert lgr.getPsesLast(key) == None assert lgr.cntPses(key) == 0 assert lgr.delPses(key) == False assert lgr.putPses(key, vals) == True assert lgr.getPses(key) == vals # preserved insertion order assert lgr.cntPses(key) == len(vals) == 4 assert lgr.getPsesLast(key) == vals[-1] assert lgr.putPses(key, vals=[b'a']) == False # duplicate assert lgr.getPses(key) == vals # no change assert lgr.addPse(key, b'a') == False # duplicate assert lgr.addPse(key, b'b') == True assert lgr.getPses(key) == [b"z", b"m", b"x", b"a", b"b"] assert lgr.delPses(key) == True assert lgr.getPses(key) == [] # test .ooes insertion order dup methods. dup vals are insertion order key = b'A' vals = [b"z", b"m", b"x", b"a"] assert lgr.getOoes(key) == [] assert lgr.getOoesLast(key) == None assert lgr.cntOoes(key) == 0 assert lgr.delOoes(key) == False assert lgr.putOoes(key, vals) == True assert lgr.getOoes(key) == vals # preserved insertion order assert lgr.cntOoes(key) == len(vals) == 4 assert lgr.getOoesLast(key) == vals[-1] assert lgr.putOoes(key, vals=[b'a']) == False # duplicate assert lgr.getOoes(key) == vals # no change assert lgr.addOoe(key, b'a') == False # duplicate assert lgr.addOoe(key, b'b') == True assert lgr.getOoes(key) == [b"z", b"m", b"x", b"a", b"b"] assert lgr.delOoes(key) == True assert lgr.getOoes(key) == [] # test .dels insertion order dup methods. dup vals are insertion order key = b'A' vals = [b"z", b"m", b"x", b"a"] assert lgr.getDes(key) == [] assert lgr.getDesLast(key) == None assert lgr.cntDes(key) == 0 assert lgr.delDes(key) == False assert lgr.putDes(key, vals) == True assert lgr.getDes(key) == vals # preserved insertion order assert lgr.cntDes(key) == len(vals) == 4 assert lgr.getDesLast(key) == vals[-1] assert lgr.putDes(key, vals=[b'a']) == False # duplicate assert lgr.getDes(key) == vals # no change assert lgr.addDe(key, b'a') == False # duplicate assert lgr.addDe(key, b'b') == True assert lgr.getDes(key) == [b"z", b"m", b"x", b"a", b"b"] assert lgr.delDes(key) == True assert lgr.getDes(key) == [] # test .ldes insertion order dup methods. dup vals are insertion order key = b'A' vals = [b"z", b"m", b"x", b"a"] assert lgr.getLdes(key) == [] assert lgr.getLdesLast(key) == None assert lgr.cntLdes(key) == 0 assert lgr.delLdes(key) == False assert lgr.putLdes(key, vals) == True assert lgr.getLdes(key) == vals # preserved insertion order assert lgr.cntLdes(key) == len(vals) == 4 assert lgr.getLdesLast(key) == vals[-1] assert lgr.putLdes(key, vals=[b'a']) == False # duplicate assert lgr.getLdes(key) == vals # no change assert lgr.delLdes(key) == True assert lgr.getLdes(key) == [] assert not os.path.exists(lgr.path) """ End Test """
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_direct_mode_with_manager(): """ Test direct mode with transferable validator event receipts """ # manual process to generate a list of secrets # root = pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES) # secrets = generateSecrets(root=root, count=8) # Direct Mode initiated by coe is controller, val is validator # but goes both ways once initiated. # set of secrets (seeds for private keys) coeSalt = Salter(raw=b'0123456789abcdea').qb64 # set of secrets (seeds for private keys) valSalt = Salter(raw=b'1123456789abcdea').qb64 with openDB("controller") as coeLogger, openDB("validator") as valLogger, openKS(name="controller") as coeKpr, openKS(name="validator") as valKpr: # Init key pair manager coeMgr = Manager(keeper=coeKpr, salt=coeSalt) coeVerfers, coeDigers = coeMgr.incept(icount=1, ncount=1) # init Keverys coeKevery = Kevery(db=coeLogger) valKevery = Kevery(db=valLogger) coe_event_digs = [] # list of controller's own event log digs to verify against database val_event_digs = [] # list of validator's own event log digs to verify against database # init sequence numbers for both controller and validator csn = cesn = 0 # sn and last establishment sn = esn vsn = vesn = 0 # sn and last establishment sn = esn # Controller Event 0 Inception Transferable (nxt digest not empty) coeSerder = incept(keys=[coeVerfers[0].qb64], nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert csn == int(coeSerder.ked["s"], 16) == 0 coepre = coeSerder.ked["i"] assert coepre == 'EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas' coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(ser=coeSerder.raw, verfers=coeVerfers) # create serialized message cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"0","t":"icp","kt":"1","k":["Dpt7mGZ3y5UmhT1NLEx' b'b1IW8vMJ8ylQW3K44LfkTgAqE"],"n":"Erpltchg7BUv21Qz3ZXhOhVu63m7S7Y' b'bPb21lSeGYd90","wt":"0","w":[],"c":[]}-AABAA2dW-FXhcUiGQZh1JhRrh' b'_JDqEPU678KT0U8F_a-l8Q3sO25xJAs3Iu2bBonBPZjVo_Zc8FVqrqXjQxxUPt4ICg') # create own Controller Kever in Controller's Kevery coeKevery.processOne(ims=bytearray(cmsg)) # send copy of cmsg coeKever = coeKevery.kevers[coepre] assert coeKever.prefixer.qb64 == coepre # Validator Event 0 Inception Transferable (nxt digest not empty) # Init key pair manager valMgr = Manager(keeper=valKpr, salt=valSalt) valVerfers, valDigers = valMgr.incept(icount=1, ncount=1) valSerder = incept(keys=[valVerfers[0].qb64], nxt=Nexter(digs=[valDigers[0].qb64]).qb64, code=MtrDex.Blake3_256) assert vsn == int(valSerder.ked["s"], 16) == 0 valpre = valSerder.ked["i"] assert valpre == 'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0' val_event_digs.append(valSerder.dig) # sign serialization sigers = valMgr.sign(valSerder.raw, verfers=valVerfers) # return Siger if index # create serialized message vmsg = messagize(valSerder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}-AABAAxvl1581mKQME95XZrjsy' b'CXxJ3fCnmNSG_Bc1I4FcxEoeQbgdLAQ8sudwb0FHOYXfqRE6Z7PraaU82YQDyVShDw') # create own Validator Kever in Validator's Kevery valKevery.processOne(ims=bytearray(vmsg)) # send copy of vmsg valKever = valKevery.kevers[valpre] assert valKever.prefixer.qb64 == valpre # simulate sending of controller's inception message to validator valKevery.process(ims=bytearray(cmsg)) # make copy of msg assert coepre in valKevery.kevers # creates Kever for controller in validator's .kevers # create receipt of controller's inception # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) coeK = valKevery.kevers[coepre] # lookup coeKever from validator's .kevers # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # Validate receipt assert reserder.raw == (b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","a":{"i' b'":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7x' b'HnuE-wyiarIZ9j-1CEQ89I0E3WevcE"}}') # sign controller's event not receipt # look up event to sign from validator's kever for coe coeIcpDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIcpDig == coeK.serder.diger.qb64b == b'Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc' coeIcpRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIcpDig))) assert coeIcpRaw == (b'{"v":"KERI10JSON0000e6_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"icp","kt":"1","k":["Dpt7mGZ3y5UmhT1NLExb1IW8vMJ8ylQW3K44LfkTgAq' b'E"],"n":"Erpltchg7BUv21Qz3ZXhOhVu63m7S7YbPb21lSeGYd90","wt":"0","w":[],"c":[' b']}') counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # process own validator receipt in validator's Kevery so have copy in own log rmsg = messagize(reserder, sigers) assert rmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","a":{"i' b'":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7x' b'HnuE-wyiarIZ9j-1CEQ89I0E3WevcE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwy' b'qst_ZvLo05jau9GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') valKevery.processOne(ims=bytearray(rmsg)) # process copy of rmsg # attach receipt message to existing message with validators inception message # simulate streaming. validator first sends it's inception event, then sends a receipt to controller vmsg.extend(rmsg) assert vmsg == bytearray(b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}-AABAAxvl1581mKQME95XZrjsy' b'CXxJ3fCnmNSG_Bc1I4FcxEoeQbgdLAQ8sudwb0FHOYXfqRE6Z7PraaU82YQDyVSh' b'Dw{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14Vk' b'BOCJnPYabcas","s":"0","t":"vrc","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us' b'-0juFL5hOAHAwIEkc","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFB' b'DyVSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3W' b'evcE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyqst_ZvLo05jau9' b'GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') # Simulate sending validator's inception event and receipt of controller's inception message to controller coeKevery.process(ims=vmsg) # controller process validator's inception and receipt # check if validator's Kever in controller's .kevers assert valpre in coeKevery.kevers # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyq' b'st_ZvLo05jau9GsF0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') # create receipt to escrow use invalid digest and sequence number so not in controller's db fake = reserder.dig # some other digest reserder = chit(pre=coeK.prefixer.qb64, sn=10, dig=fake, seal=seal) # sign event not receipt sigers = valMgr.sign(ser=coeIcpRaw, verfers=valVerfers) # return Siger if index # create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"a","t":"vrc","d":"EwxY7Vhkeyr7LBnLAzdGXZzSmTmJV' b'RctQfNUO0YUqeOU","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAARG0my55RTX81fFzUbbcfygZXfz04VglNA8Zwyqst_ZvLo05jau9Gs' b'F0IS9Vm6yGr8QQPdB7M4oVkrd9IEZ8PDA') coeKevery.process(ims=vmsg) # controller process the escrow receipt from validator # check if receipt quadruple in escrow database result = coeKevery.db.getVres(key=snKey(pre=coeKever.prefixer.qb64, sn=10)) assert bytes(result[0]) == (fake.encode("utf-8") + valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) # Send receipt from controller to validator # create receipt of validator's inception # create seal of controller's last establishment event seal = SealEvent(i=coepre, s="{:x}".format(coeKever.lastEst.s), d=coeKever.lastEst.d) valK = coeKevery.kevers[valpre] # lookup valKever from controller's .kevers # create validator receipt reserder = chit(pre=valK.prefixer.qb64, sn=valK.sn, dig=valK.serder.diger.qb64, seal=seal) # sign validator's event not receipt # look up event to sign from controller's kever for validator valIcpDig = bytes(coeKevery.db.getKeLast(key=snKey(pre=valpre, sn=vsn))) assert valIcpDig == valK.serder.diger.qb64b == b'ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcE' valIcpRaw = bytes(coeKevery.db.getEvt(key=dgKey(pre=valpre, dig=valIcpDig))) assert valIcpRaw == (b'{"v":"KERI10JSON0000e6_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"icp","kt":"1","k":["DLSBUmklGu6eLqnA5DA' b'gj41jetAJYkyn34crqejwXxVw"],"n":"EwmUJaS6DSPRQprlGp_3CIg8BZwmaJl' b'KPlE4LHcx0Zms","wt":"0","w":[],"c":[]}') counter = Counter(CtrDex.ControllerIdxSigs) assert counter.qb64 == '-AAB' sigers = coeMgr.sign(ser=valIcpRaw, verfers=coeVerfers) # return Siger if index # create receipt message cmsg = messagize(reserder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqF' b'BDyVSOXYW0","s":"0","t":"vrc","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-' b'1CEQ89I0E3WevcE","a":{"i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJn' b'PYabcas","s":"0","d":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIE' b'kc"}}-AABAAKXFMBGw559YHoxyeDrmpilQo5JMbr5WSfYTn1IXV_rMtg23_GHrNQ' b'Ua7y45UkNftT48O0MekxT7geRBU84dACA') # controller process own receipt in own Kevery so have copy in own log coeKevery.processOne(ims=bytearray(cmsg)) # make copy # Simulate sending controller's receipt of validator's inception message to validator valKevery.process(ims=cmsg) # controller process validator's inception and receipt # check if receipt quadruple from controller in validator's receipt database result = valKevery.db.getVrcs(key=dgKey(pre=valKever.prefixer.qb64, dig=valKever.serder.diger.qb64)) assert bytes(result[0]) == (coeKever.prefixer.qb64b + Seqner(sn=coeKever.sn).qb64b + coeKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas0AAAAAAAAAAAAAAAAAAAAAAAEy2pXEna' b'oQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkcAAKXFMBGw559YHoxyeDrmpilQo5JMbr5WSfYTn1I' b'XV_rMtg23_GHrNQUa7y45UkNftT48O0MekxT7geRBU84dACA') # Controller Event 1 Rotation Transferable csn += 1 cesn += 1 assert csn == cesn == 1 coeVerfers, coeDigers = coeMgr.rotate(coeVerfers[0].qb64) coeSerder = rotate(pre=coeKever.prefixer.qb64, keys=[coeVerfers[0].qb64], dig=coeKever.serder.diger.qb64, nxt=Nexter(digs=[coeDigers[0].qb64]).qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # returns sigers # create serialized message cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000122_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"1","t":"rot","p":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0' b'juFL5hOAHAwIEkc","kt":"1","k":["D-HwiqmaETxls3vAVSh0xpXYTs94NUJX' b'6juupWj_EgsA"],"n":"ED6lKZwg-BWl_jlCrjosQkOEhqKD4BJnlqYqWmhqPhaU' b'","wt":"0","wr":[],"wa":[],"a":[]}-AABAAsDhyw43CAo29zyTZ7WIuztBG' b'L3WELM78qSwaEYh8NzwNAPqDtiuL-QmKd22om1qYGDU7cuFM-AlTKaFjsVOzBg') # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's rotation # create seal of validator's last establishment event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeRotDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeRotDig == coeK.serder.diger.qb64b == b'EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek' coeRotRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeRotDig))) assert coeRotRaw == (b'{"v":"KERI10JSON000122_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"1","t":"rot","p":"Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc","kt":"1' b'","k":["D-HwiqmaETxls3vAVSh0xpXYTs94NUJX6juupWj_EgsA"],"n":"ED6lKZwg-BWl_jlC' b'rjosQkOEhqKD4BJnlqYqWmhqPhaU","wt":"0","wr":[],"wa":[],"a":[]}') sigers = valMgr.sign(ser=coeRotRaw, verfers=valVerfers) # validator create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"1","t":"vrc","d":"EO7V6wDClWWiN_7sfGDTD8KsfRQaH' b'yap6fz_O4CYvsek","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAAjVFBjhbM2RdHKEk2rtHA0tXMe0iswn6IS5ShALtR3JHMz-NePCN_f' b'lUEUbV2F22CGRgmnCe71n42ywWyzsFmDg') # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAAjVFBjhbM2RdHKEk2rtHA0tXMe0iswn6IS5ShAL' b'tR3JHMz-NePCN_flUEUbV2F22CGRgmnCe71n42ywWyzsFmDg') # Next Event 2 Controller Interaction csn += 1 # do not increment esn assert csn == 2 assert cesn == 1 coeSerder = interact(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64, sn=csn) coe_event_digs.append(coeSerder.dig) # sign serialization sigers = coeMgr.sign(coeSerder.raw, verfers=coeVerfers) # create msg cmsg = messagize(coeSerder, sigers) assert cmsg == bytearray(b'{"v":"KERI10JSON000098_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"2","t":"ixn","p":"EO7V6wDClWWiN_7sfGDTD8KsfRQaH' b'yap6fz_O4CYvsek","a":[]}-AABAAstaU9Hu1ti8erlnFwEdCrXWkkkW_ydYgrr' b'ryB6EtEOrWY_tQh5jZLGRWrClefeX6AfDDw7JS5JY15n8_ueJWBQ') # update controller's key event verifier state coeKevery.processOne(ims=bytearray(cmsg)) # make copy # verify controller's copy of controller's event stream is updated assert coeKever.sn == csn assert coeKever.serder.diger.qb64 == coeSerder.dig # simulate send message from controller to validator valKevery.process(ims=cmsg) # verify validator's copy of controller's event stream is updated assert coeK.sn == csn assert coeK.serder.diger.qb64 == coeSerder.dig # create receipt of controller's interaction # create seal of validator's last est event seal = SealEvent(i=valpre, s="{:x}".format(valKever.lastEst.s), d=valKever.lastEst.d) # create validator receipt reserder = chit(pre=coeK.prefixer.qb64, sn=coeK.sn, dig=coeK.serder.diger.qb64, seal=seal) # sign controller's event not receipt # look up event to sign from validator's kever for controller coeIxnDig = bytes(valKevery.db.getKeLast(key=snKey(pre=coepre, sn=csn))) assert coeIxnDig == coeK.serder.diger.qb64b == b'EuCLxtdKdRgzzgBnPhTwFKz36u58DqQyMqhX5CUrurPE' coeIxnRaw = bytes(valKevery.db.getEvt(key=dgKey(pre=coepre, dig=coeIxnDig))) assert coeIxnRaw == (b'{"v":"KERI10JSON000098_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBOCJnPYabcas",' b'"s":"2","t":"ixn","p":"EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek","a":[]}') sigers = valMgr.sign(ser=coeIxnRaw, verfers=valVerfers) # create receipt message vmsg = messagize(reserder, sigers) assert vmsg == bytearray(b'{"v":"KERI10JSON000105_","i":"EsU9ZQwug7DS-GU040Ugj1t7p6Au14VkBO' b'CJnPYabcas","s":"2","t":"vrc","d":"EuCLxtdKdRgzzgBnPhTwFKz36u58D' b'qQyMqhX5CUrurPE","a":{"i":"EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDy' b'VSOXYW0","s":"0","d":"ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3Wev' b'cE"}}-AABAAboeSfNNgX04wuUrQp-3eY0oUzcLYnLUmtqYETBZqXEL97pjSjmm81' b'1KzCRu2cnSHVlKqzIaEBaXyBpWBDexLBQ') # ------------------------------END CONVERTED CODE------------------------------ # validator process own receipt in own kevery so have copy in own log valKevery.processOne(ims=bytearray(vmsg)) # make copy # Simulate send to controller of validator's receipt of controller's rotation message coeKevery.process(ims=vmsg) # controller process validator's incept and receipt # check if receipt quadruple from validator in receipt database result = coeKevery.db.getVrcs(key=dgKey(pre=coeKever.prefixer.qb64, dig=coeKever.serder.diger.qb64)) assert bytes(result[0]) == (valKever.prefixer.qb64b + Seqner(sn=valKever.sn).qb64b + valKever.serder.diger.qb64b + sigers[0].qb64b) assert bytes(result[0]) == (b'EBiIFxr_o1b4x1YR21PblAFpFG61qDghqFBDyVSOXYW00AAAAAAAAAAAAAAAAAAAAAAAElsHFkbZ' b'QjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcEAAboeSfNNgX04wuUrQp-3eY0oUzcLYnLUmtqYETB' b'ZqXEL97pjSjmm811KzCRu2cnSHVlKqzIaEBaXyBpWBDexLBQ') # verify final controller event state assert coeKever.sn == coeK.sn == csn db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs == ['Ey2pXEnaoQVwxA4jB6k0QH5G2Us-0juFL5hOAHAwIEkc', 'EO7V6wDClWWiN_7sfGDTD8KsfRQaHyap6fz_O4CYvsek', 'EuCLxtdKdRgzzgBnPhTwFKz36u58DqQyMqhX5CUrurPE'] db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(coepre)] assert len(db_digs) == len(coe_event_digs) == csn + 1 assert db_digs == coe_event_digs # verify final validator event state assert valKever.sn == valK.sn == vsn db_digs = [bytes(v).decode("utf-8") for v in valKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs == ['ElsHFkbZQjRb7xHnuE-wyiarIZ9j-1CEQ89I0E3WevcE'] db_digs = [bytes(v).decode("utf-8") for v in coeKever.baser.getKelIter(valpre)] assert len(db_digs) == len(val_event_digs) == vsn + 1 assert db_digs == val_event_digs assert not os.path.exists(valKevery.db.path) assert not os.path.exists(coeKever.baser.path)
def test_tever_backers(mockHelpingNowUTC): # registry with backer and receipt with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg( ) as reg: valSecret = 'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw' # create receipt signer prefixer default code is non-transferable valSigner = Signer(qb64=valSecret, transferable=False) valPrefixer = Prefixer(qb64=valSigner.verfer.qb64) valpre = valPrefixer.qb64 assert valpre == 'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc' hab = buildHab(db, kpr) vcp = eventing.incept(hab.pre, baks=[valpre], toad=1, cnfg=[], code=MtrDex.Blake3_256) regk = vcp.pre valCigar = valSigner.sign(ser=vcp.raw, index=0) # successfully anchor to a rotation event rseal = SealEvent(i=regk, s=vcp.ked["s"], d=vcp.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev = Tever(serder=vcp, seqner=seqner, diger=diger, bigers=[valCigar], db=db, reger=reg) dgkey = dgKey(pre=regk, dig=vcp.dig) assert reg.getTvt(dgkey) == ( b'{"v":"KERI10JSON0000d7_","i":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU",' b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],' b'"bt":"1",' b'"b":["B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc"]}') assert reg.getAnc( dgkey ) == b'0AAAAAAAAAAAAAAAAAAAAAAQEpWPsFsCcsu5SpVH0416qHx3gvG0CWlrP_i7BVdbmRBg' assert reg.getTel(snKey( pre=regk, sn=0)) == b'EJTWiS0ebp8VSyLr38x73dAHdUqivisUtAaGpEHt5HDc' assert [bytes(tib) for tib in reg.getTibs(dgkey)] == [ b'AAGhpPxAoltsRAnqxf7NsBzWSxWYLZ_ALImVVBiTlzJSdlATxRp_hBK4AbOzu-a900hwRxa0RX-yVWbVJA6oxoBw' ] assert reg.getTwe(snKey(pre=regk, sn=0)) is None debSecret = 'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ' # create receipt signer prefixer default code is non-transferable debSigner = Signer(qb64=debSecret, transferable=False) debPrefixer = Prefixer(qb64=debSigner.verfer.qb64) debpre = debPrefixer.qb64 assert debpre == 'BbWeWTNGXPMQrVuJmScNQn81YF7T2fhh2kXwT8E_NbeI' vrt = eventing.rotate(regk, dig=vcp.dig, baks=[valpre], adds=[debpre]) valCigar = valSigner.sign(ser=vrt.raw, index=0) debCigar = debSigner.sign(ser=vrt.raw, index=1) # successfully anchor to a rotation event rseal = SealEvent(regk, vrt.ked["s"], vrt.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev.update(serder=vrt, seqner=seqner, diger=diger, bigers=[valCigar, debCigar]) assert tev.baks == [ 'B8KY1sKmgyjAiUDdUBPNPyrSz_ad_Qf9yzhDNZlEKiMc', 'BbWeWTNGXPMQrVuJmScNQn81YF7T2fhh2kXwT8E_NbeI' ] vcdig = b'EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU' bis = eventing.backerIssue(vcdig=vcdig.decode("utf-8"), regk=regk, regsn=tev.sn, regd=tev.serder.dig) valCigar = valSigner.sign(ser=bis.raw, index=0) debCigar = debSigner.sign(ser=bis.raw, index=1) # successfully anchor to a rotation event rseal = SealEvent(bis.ked["i"], bis.ked["s"], bis.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev.update(bis, seqner=seqner, diger=diger, bigers=[valCigar, debCigar]) vci = nsKey([regk, vcdig]) dgkey = dgKey(pre=vci, dig=bis.dig) assert bytes(reg.getTvt(dgkey)) == ( b'{"v":"KERI10JSON00012d_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",' b'"ii":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU","s":"0","t":"bis","ra":{' b'"i":"EBZR8LxEozgFa6UXwtSAmiXsmdChrT7Hr-jcxc9NFfrU","s":1,"d":"EZH2Cfw3nvcMRg' b'Y31Jyc2zHVh4a0LO_bVZ4EmL4V8Ol8"},"dt":"2021-01-01T00:00:00.000000+00:00"}' )
def test_tever_no_backers(mockHelpingNowUTC): # registry with no backers # registry with backer and receipt with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg( ) as reg: hab = buildHab(db, kpr) vcp = eventing.incept(hab.pre, baks=[], toad=0, cnfg=["NB"], code=MtrDex.Blake3_256) regk = vcp.pre # successfully anchor to a rotation event rseal = SealEvent(i=regk, s=vcp.ked["s"], d=vcp.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev = Tever(serder=vcp, seqner=seqner, diger=diger, db=db, reger=reg) assert tev.prefixer.qb64 == vcp.pre assert tev.sn == 0 dgkey = dgKey(pre=regk, dig=vcp.dig) assert reg.getTvt(dgkey) == ( b'{"v":"KERI10JSON0000ad_","i":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw",' b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":["NB"],"bt":"0","b":[]}' ) assert reg.getAnc(dgkey) == ( b'0AAAAAAAAAAAAAAAAAAAAAAQE-yQ6BjCaJg-u2mNuE-ycVWVTq7IZ8TuN-Ew8soLijSA' ) assert reg.getTel(snKey( pre=regk, sn=0)) == b'ElYstqTocyQixLLz4zYCAs2unaFco_p6LqH0W01loIg4' assert reg.getTibs(dgkey) == [] assert reg.getTwe(snKey(pre=regk, sn=0)) is None # try to rotate a backerless registry vrt = eventing.rotate(regk, dig=vcp.dig) rseal = SealEvent(regk, vrt.ked["s"], vrt.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger # should raise validation err because rotation is not supported with pytest.raises(ValidationError): tev.update(serder=vrt, seqner=seqner, diger=diger) vcdig = b'EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU' iss = eventing.issue(vcdig=vcdig.decode("utf-8"), regk=regk) # successfully anchor to a rotation event rseal = SealEvent(iss.ked["i"], iss.ked["s"], iss.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev.update(iss, seqner=seqner, diger=diger) vci = nsKey([regk, vcdig]) dgkey = dgKey(pre=vci, dig=iss.dig) assert bytes(reg.getTvt(dgkey)) == ( b'{"v":"KERI10JSON0000ba_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",' b'"s":"0","t":"iss","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw","dt":"' b'2021-01-01T00:00:00.000000+00:00"}') assert bytes( reg.getAnc(dgkey) ) == b'0AAAAAAAAAAAAAAAAAAAAAAwEJLLpuUKPSDIcoOAOArQBzceWc8MoShm-cDL-w81liIw' # revoke vc with no backers rev = eventing.revoke(vcdig=vcdig.decode("utf-8"), regk=regk, dig=iss.dig) # successfully anchor to a rotation event rseal = SealEvent(rev.ked["i"], rev.ked["s"], rev.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger tev.update(rev, seqner=seqner, diger=diger) dgkey = dgKey(pre=vci, dig=rev.dig) assert bytes(reg.getTvt(dgkey)) == ( b'{"v":"KERI10JSON0000ed_","i":"EEBp64Aw2rsjdJpAR0e2qCq3jX7q7gLld3LjAwZgaLXU",' b'"s":"1","t":"rev","ri":"Ezm53Qww2LTJ1yksEL06Wtt-5D23QKdJEGI0egFyLehw","p":"E' b'C9PffPrvyaKzsn72SWTvgyvWCJ1FbDThvJhsQ9LWo9M","dt":"2021-01-01T00:00:00.00000' b'0+00:00"}')
def test_tever_escrow(): with pytest.raises(TypeError): Tever() # registry with no backers, invalid anchor with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg( ) as reg: hab = buildHab(db, kpr) vcp = eventing.incept(hab.pre, baks=[], toad=0, cnfg=[], code=MtrDex.Blake3_256) regk = vcp.pre assert regk == "EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY" assert vcp.dig == "EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg" assert vcp.ked["ii"] == hab.pre # anchor to nothing, exception expected seqner = Seqner(sn=4) # invalid seal sn with pytest.raises(ValidationError): Tever(serder=vcp, seqner=seqner, diger=None, db=db, reger=reg) # registry with no backers with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg( ) as reg: hab = buildHab(db, kpr) vcp = eventing.incept(hab.pre, baks=[], toad=0, cnfg=[], code=MtrDex.Blake3_256) regk = vcp.pre # anchoring event not in db, exception and escrow seqner = Seqner(sn=1) with pytest.raises(MissingAnchorError): Tever(serder=vcp, seqner=seqner, db=db, reger=reg) dgkey = dgKey(pre=regk, dig=vcp.dig) assert reg.getTvt(dgkey) == ( b'{"v":"KERI10JSON0000a9_","i":"EoN_Ln_JpgqsIys-jDOH8oWdxgWqs7hzkDGeLWHb9vSY",' b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"0","b":[]}' ) assert reg.getTae(snKey( pre=regk, sn=0)) == b'EvpB-_BWD7tOhLI0cDyEQbziBt6IMyQnkrh0booR4vhg' # registry with backers, no signatures. should escrow with basing.openDB() as db, keeping.openKS() as kpr, viring.openReg( ) as reg: hab = buildHab(db, kpr) vcp = eventing.incept( hab.pre, baks=["BoOcciw30IVQsaenKXpiyMVrjtPDW3KeD_6KFnSfoaqI"], toad=1, cnfg=[], code=MtrDex.Blake3_256) regk = vcp.pre # successfully anchor to a rotation event rseal = SealEvent(regk, vcp.ked["s"], vcp.diger.qb64) rot = hab.rotate(data=[rseal._asdict()]) rotser = Serder(raw=rot) seqner = Seqner(sn=int(rotser.ked["s"], 16)) diger = rotser.diger with pytest.raises(MissingWitnessSignatureError): Tever(serder=vcp, seqner=seqner, diger=diger, db=db, reger=reg) dgkey = dgKey(pre=regk, dig=vcp.dig) assert reg.getTvt(dgkey) == ( b'{"v":"KERI10JSON0000d7_","i":"E1cv04kvHvWPrfncYsq-lQ-QvyKmKz6-hlGj02B2QWbk",' b'"ii":"EaKJ0FoLxO1TYmyuprguKO7kJ7Hbn0m0Wuk5aMtSrMtY","s":"0","t":"vcp","c":[],"bt":"1",' b'"b":["BoOcciw30IVQsaenKXpiyMVrjtPDW3KeD_6KFnSfoaqI"]}') assert reg.getAnc(dgkey) == ( b'0AAAAAAAAAAAAAAAAAAAAAAQE1NdOqtN0HlhBPc7-MHvsA4vajMwFYp2eIturQQo0stM' ) assert reg.getTel(snKey(pre=regk, sn=0)) is None assert reg.getTwe(snKey( pre=regk, sn=0)) == b'EjhsbizNCwN_EFuOxbUt8CN0xOctGRIVOW8X-XqA3fSk'