def test_direct_mode_bob_eve_demo():
"""
Test direct mode bob and eve
"""
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
bobSecrecies = []
for secret in bobSecrets: # convert secrets to secrecies
bobSecrecies.append([secret])
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
bob = bobSerder.ked["i"]
assert bob == 'EH7Oq9oxCgYa-nnNLvwhp9sFZpALILlRYyB-6n4WDi7w'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
eveSecrecies = []
for secret in eveSecrets: # convert secrets to secrecies
eveSecrecies.append([secret])
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
eve = eveSerder.ked["i"]
assert eve == 'EpDA1n-WiBA0A8YOqnKrB-wWQYYC49i5zY_qrIZIicQg'
with dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \
dbing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS:
limit = 1.0
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(name='Bob',
ks=bobKS,
db=bobDB,
kevers=bobKevers,
secrecies=bobSecrecies,
temp=True)
assert bobHab.ks == bobKS
assert bobHab.db == bobDB
assert bobHab.iserder.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=evePort)
bobClientDoer = doing.ClientDoer(client=bobClient)
bobDirector = demoing.BobDirector(hab=bobHab,
client=bobClient,
tock=0.125)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert bobDirector.hab.kvy.kevers == bobKevers
assert bobDirector.hab.kvy.db == bobDB
assert bobDirector.tock == 0.125
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert bobReactor.hab.kvy.kevers == bobKevers
assert bobReactor.hab.kvy.db == bobDB
assert bobReactor.hab.kvy.ims == bobReactor.client.rxbs
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(name='Eve',
ks=eveKS,
db=eveDB,
kevers=eveKevers,
secrecies=eveSecrecies,
temp=True)
assert eveHab.ks == eveKS
assert eveHab.db == eveDB
assert eveHab.iserder.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=bobPort)
eveClientDoer = doing.ClientDoer(client=eveClient)
eveDirector = demoing.EveDirector(hab=eveHab,
client=eveClient,
tock=0.125)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert eveDirector.hab.kvy.kevers == eveKevers
assert eveDirector.hab.kvy.db == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert eveReactor.hab.kvy.kevers == eveKevers
assert eveReactor.hab.kvy.db == eveDB
assert eveReactor.hab.kvy.ims == eveReactor.client.rxbs
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert bobHab.pre in bobHab.kevers
assert eveHab.pre in eveHab.kevers
assert not bobClient.txbs
assert bobHab.pre in eveHab.kevers
# verify final event states
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_crypt_signer_suber():
"""
test Manager class with aeid
"""
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed0 = (
b'\x18;0\xc4\x0f*vF\xfa\xe3\xa2Eee\x1f\x96o\xce)G\x85\xe3X\x86\xda\x04\xf0\xdc'
b'\xde\x06\xc0+')
signer0 = coring.Signer(raw=seed0, code=coring.MtrDex.Ed25519_Seed)
assert signer0.verfer.code == coring.MtrDex.Ed25519
assert signer0.verfer.transferable # default
assert signer0.qb64b == b'AGDswxA8qdkb646JFZWUflm_OKUeF41iG2gTw3N4GwCs'
assert signer0.verfer.qb64b == b'DhixhZjC1Wj2bLR1QdADT79kS2zwHld29ekca0elxHiE'
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed1 = (
b'`\x05\x93\xb9\x9b6\x1e\xe0\xd7\x98^\x94\xc8Et\xf2\xc4\xcd\x94\x18'
b'\xc6\xae\xb9\xb6m\x12\xc4\x80\x03\x07\xfc\xf7')
signer1 = coring.Signer(raw=seed1, code=coring.MtrDex.Ed25519_Seed)
assert signer1.verfer.code == coring.MtrDex.Ed25519
assert signer1.verfer.transferable # default
assert signer1.qb64b == b'AYAWTuZs2HuDXmF6UyEV08sTNlBjGrrm2bRLEgAMH_Pc'
assert signer1.verfer.qb64b == b'Dgekf6SB_agwx96mVSZI6PTC09j4Sp8qUbgKglN8uLjY'
# rawsalt =pysodium.randombytes(pysodium.crypto_pwhash_SALTBYTES)
rawsalt = b'0123456789abcdef'
salter = coring.Salter(raw=rawsalt)
salt = salter.qb64
assert salt == '0AMDEyMzQ1Njc4OWFiY2RlZg'
stem = "blue"
# cryptseed0 = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
cryptseed0 = b'h,#|\x8ap"\x12\xc43t2\xa6\xe1\x18\x19\xf0f2,y\xc4\xc21@\xf5@\x15.\xa2\x1a\xcf'
cryptsigner0 = coring.Signer(raw=cryptseed0,
code=coring.MtrDex.Ed25519_Seed,
transferable=False)
seed0 = cryptsigner0.qb64
aeid0 = cryptsigner0.verfer.qb64
assert aeid0 == 'BJruYr3oXDGRTRN0XnhiqDeoENdRak6FD8y2vsTvvJkE'
decrypter = coring.Decrypter(seed=seed0)
encrypter = coring.Encrypter(verkey=aeid0)
assert encrypter.verifySeed(seed=seed0)
# cryptseed1 = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
cryptseed1 = (
b"\x89\xfe{\xd9'\xa7\xb3\x89#\x19\xbec\xee\xed\xc0\xf9\x97\xd0\x8f9\x1dyNI"
b'I\x98\xbd\xa4\xf6\xfe\xbb\x03')
cryptsigner1 = coring.Signer(raw=cryptseed1,
code=coring.MtrDex.Ed25519_Seed,
transferable=False)
with dbing.openLMDB() as db, keeping.openKS() as ks:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.CryptSignerSuber(db=db,
subkey='bags.') # default klas is Signer
assert isinstance(sdb, subing.CryptSignerSuber)
assert issubclass(sdb.klas, coring.Signer)
# Test without encrypter or decrypter
keys = (signer0.verfer.qb64,
) # must be verfer as key to get transferable
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# try put different val when already put
result = sdb.put(keys=keys, val=signer1)
assert not result
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# now overwrite with pin. Key is wrong but transferable property is
# the same so that is all that matters to get back signer
result = sdb.pin(keys=keys, val=signer1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer1.qb64
assert actual.verfer.qb64 == signer1.verfer.qb64
# test with keys as string not tuple
keys = signer0.verfer.qb64
sdb.pin(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
assert not sdb.get(keys=keys)
# test missing entry at keys
badkey = b'D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE'
assert not sdb.get(badkey)
# test iteritems
sdb = subing.CryptSignerSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.CryptSignerSuber)
assert sdb.put(keys=signer0.verfer.qb64b, val=signer0)
assert sdb.put(keys=signer1.verfer.qb64b, val=signer1)
items = [(keys, sgnr.qb64) for keys, sgnr in sdb.getItemIter()]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# now test with encrypter and decrypter
encrypter0 = coring.Encrypter(verkey=cryptsigner0.verfer.qb64)
decrypter0 = coring.Decrypter(seed=cryptsigner0.qb64b)
# first pin with encrypter
assert sdb.pin(keys=signer0.verfer.qb64b,
val=signer0,
encrypter=encrypter0)
assert sdb.pin(keys=signer1.verfer.qb64b,
val=signer1,
encrypter=encrypter0)
# now get
actual0 = sdb.get(keys=signer0.verfer.qb64b, decrypter=decrypter0)
assert isinstance(actual0, coring.Signer)
assert actual0.qb64 == signer0.qb64
assert actual0.verfer.qb64 == signer0.verfer.qb64
actual1 = sdb.get(keys=signer1.verfer.qb64b, decrypter=decrypter0)
assert isinstance(actual1, coring.Signer)
assert actual1.qb64 == signer1.qb64
assert actual1.verfer.qb64 == signer1.verfer.qb64
# now get without decrypter
with pytest.raises(ValueError):
actual0 = sdb.get(keys=signer0.verfer.qb64b)
with pytest.raises(ValueError):
actual1 = sdb.get(keys=signer1.verfer.qb64b)
# remove and test put
sdb.rem(keys=signer0.verfer.qb64b)
assert not sdb.get(keys=signer0.verfer.qb64b)
sdb.rem(keys=signer1.verfer.qb64b)
assert not sdb.get(keys=signer1.verfer.qb64b)
assert sdb.put(keys=signer0.verfer.qb64b,
val=signer0,
encrypter=encrypter0)
assert sdb.put(keys=signer1.verfer.qb64b,
val=signer1,
encrypter=encrypter0)
items = [(keys, sgnr.qb64)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter0)]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# test re-encrypt
encrypter1 = coring.Encrypter(verkey=cryptsigner1.verfer.qb64)
decrypter1 = coring.Decrypter(seed=cryptsigner1.qb64b)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter0):
sdb.pin(keys, sgnr, encrypter=encrypter1)
items = [(keys, sgnr.qb64)
for keys, sgnr in sdb.getItemIter(decrypter=decrypter1)]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
# now test with manager
manager = keeping.Manager(
ks=ks,
seed=seed0,
salt=salt,
aeid=aeid0,
)
assert manager.ks.opened
assert manager.inited
assert manager._inits == {
'aeid': 'BJruYr3oXDGRTRN0XnhiqDeoENdRak6FD8y2vsTvvJkE',
'salt': '0AMDEyMzQ1Njc4OWFiY2RlZg'
}
assert manager.encrypter.qb64 == encrypter.qb64 # aeid provided
assert manager.decrypter.qb64 == decrypter.qb64 # aeid and seed provided
assert manager.seed == seed0 # in memory only
assert manager.aeid == aeid0 # on disk only
assert manager.salt == salt # encrypted on disk but property decrypts if seed
assert manager.pidx == 0
assert manager.tier == coring.Tiers.low
saltCipher0 = coring.Cipher(qb64=manager.ks.gbls.get('salt'))
assert saltCipher0.decrypt(seed=seed0).qb64 == salt
manager.updateAeid(aeid=cryptsigner1.verfer.qb64,
seed=cryptsigner1.qb64)
assert manager.aeid == cryptsigner1.verfer.qb64 == 'BRw6sysb_uv81ZouXqHxQlqnAh9BYiSOsg9eQJmbZ8Uw'
assert manager.salt == salt
saltCipher1 = coring.Cipher(qb64=manager.ks.gbls.get('salt'))
assert not saltCipher0.qb64 == saltCipher1.qb64 # old cipher different
"""End Test"""
def test_signer_suber():
"""
Test SignerSuber LMDBer sub database class
"""
with dbing.openLMDB() as db:
assert isinstance(db, dbing.LMDBer)
assert db.name == "test"
assert db.opened
sdb = subing.SignerSuber(db=db,
subkey='bags.') # default klas is Signer
assert isinstance(sdb, subing.SignerSuber)
assert issubclass(sdb.klas, coring.Signer)
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed0 = (
b'\x18;0\xc4\x0f*vF\xfa\xe3\xa2Eee\x1f\x96o\xce)G\x85\xe3X\x86\xda\x04\xf0\xdc'
b'\xde\x06\xc0+')
signer0 = coring.Signer(raw=seed0, code=coring.MtrDex.Ed25519_Seed)
assert signer0.verfer.code == coring.MtrDex.Ed25519
assert signer0.verfer.transferable # default
assert signer0.qb64b == b'AGDswxA8qdkb646JFZWUflm_OKUeF41iG2gTw3N4GwCs'
assert signer0.verfer.qb64b == b'DhixhZjC1Wj2bLR1QdADT79kS2zwHld29ekca0elxHiE'
# preseed = pysodium.randombytes(pysodium.crypto_sign_SEEDBYTES)
seed1 = (
b'`\x05\x93\xb9\x9b6\x1e\xe0\xd7\x98^\x94\xc8Et\xf2\xc4\xcd\x94\x18'
b'\xc6\xae\xb9\xb6m\x12\xc4\x80\x03\x07\xfc\xf7')
signer1 = coring.Signer(raw=seed1, code=coring.MtrDex.Ed25519_Seed)
assert signer1.verfer.code == coring.MtrDex.Ed25519
assert signer1.verfer.transferable # default
assert signer1.qb64b == b'AYAWTuZs2HuDXmF6UyEV08sTNlBjGrrm2bRLEgAMH_Pc'
assert signer1.verfer.qb64b == b'Dgekf6SB_agwx96mVSZI6PTC09j4Sp8qUbgKglN8uLjY'
keys = (signer0.verfer.qb64,
) # must be verfer as key to get transferable
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
actual = sdb.get(keys=keys)
assert actual is None
sdb.put(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# try put different val when already put
result = sdb.put(keys=keys, val=signer1)
assert not result
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
# now overwrite with pin. Key is wrong but transferable property is
# the same so that is all that matters to get back signer
result = sdb.pin(keys=keys, val=signer1)
assert result
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer1.qb64
assert actual.verfer.qb64 == signer1.verfer.qb64
# test with keys as string not tuple
keys = signer0.verfer.qb64
sdb.pin(keys=keys, val=signer0)
actual = sdb.get(keys=keys)
assert isinstance(actual, coring.Signer)
assert actual.qb64 == signer0.qb64
assert actual.verfer.qb64 == signer0.verfer.qb64
sdb.rem(keys)
assert not sdb.get(keys=keys)
# test missing entry at keys
badkey = b'D1QdADT79kS2zwHld29hixhZjC1Wj2bLRekca0elxHiE'
assert not sdb.get(badkey)
# test iteritems
sdb = subing.SignerSuber(db=db, subkey='pugs.')
assert isinstance(sdb, subing.SignerSuber)
assert sdb.put(keys=signer0.verfer.qb64b, val=signer0)
assert sdb.put(keys=signer1.verfer.qb64b, val=signer1)
items = [(keys, srdr.qb64) for keys, srdr in sdb.getItemIter()]
assert items == [((signer1.verfer.qb64, ), signer1.qb64),
((signer0.verfer.qb64, ), signer0.qb64)]
assert not os.path.exists(db.path)
assert not db.opened
def test_directing_basic():
"""
Test directing
"""
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
bobSecrecies = []
for secret in bobSecrets: # convert secrets to secrecies
bobSecrecies.append([secret])
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
bob = bobSerder.ked["i"]
assert bob == 'EQf1hzB6s5saaQPdDAsEzSMEFoQx_WLsq93bjPu5wuqA'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
eveSecrecies = []
for secret in eveSecrets: # convert secrets to secrecies
eveSecrecies.append([secret])
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
eve = eveSerder.ked["i"]
assert eve == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
with dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \
dbing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS:
limit = 0.125
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(ks=bobKS,
db=bobDB,
kevers=bobKevers,
secrecies=bobSecrecies,
temp=True)
assert bobHab.ks == bobKS
assert bobHab.db == bobDB
assert bobHab.iserder.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=evePort)
bobClientDoer = doing.ClientDoer(tymth=doist.tymen(), client=bobClient)
bobDirector = directing.Director(hab=bobHab, client=bobClient)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert id(bobDirector.hab.kvy.kevers) == id(bobKevers)
assert bobDirector.hab.kvy.db == bobDB
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert id(bobReactor.hab.kvy.kevers) == id(bobKevers)
assert bobReactor.hab.kvy.db == bobDB
assert id(bobReactor.kevery.ims) == id(bobReactor.client.rxbs)
assert id(bobReactor.client.rxbs) == id(bobDirector.client.rxbs)
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(ks=eveKS,
db=eveDB,
kevers=eveKevers,
secrecies=eveSecrecies,
temp=True)
assert eveHab.ks == eveKS
assert eveHab.db == eveDB
assert eveHab.iserder.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=bobPort)
eveClientDoer = doing.ClientDoer(tymth=doist.tymen(), client=eveClient)
eveDirector = directing.Director(hab=eveHab, client=eveClient)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert id(eveDirector.hab.kvy.kevers) == id(eveKevers)
assert eveDirector.hab.kvy.db == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert id(eveReactor.hab.kvy.kevers) == id(eveKevers)
assert eveReactor.hab.kvy.db == eveDB
assert id(eveReactor.kevery.ims) == id(eveReactor.client.rxbs)
assert id(eveReactor.client.rxbs) == id(eveDirector.client.rxbs)
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
bobMsgTx = b"Hi Eve I am Bob"
bobDirector.client.tx(bobMsgTx)
eveMsgTx = b"Hi Bob its me Eve"
eveDirector.client.tx(eveMsgTx)
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert not bobClient.txbs
ca, ix = list(eveServer.ixes.items())[0]
eveMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert eveMsgRx == b''
# assert eveMsgRx == bobMsgTx
assert not eveClient.txbs
ca, ix = list(bobServer.ixes.items())[0]
bobMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert bobMsgRx == b''
# assert bobMsgRx == eveMsgTx
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_indirect_mode_sam_cam_wit_demo():
""" Test indirect mode, bob and eve with witness """
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
camSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
camSecrecies = []
for secret in camSecrets: # convert secrets to secrecies
camSecrecies.append([secret])
# create cam signers
camSigners = [coring.Signer(qb64=secret) for secret in camSecrets]
assert [signer.qb64 for signer in camSigners] == camSecrets
# set of secrets (seeds for private keys)
samSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
samSecrecies = []
for secret in samSecrets: # convert secrets to secrecies
samSecrecies.append([secret])
# create sam signers
samSigners = [coring.Signer(qb64=secret) for secret in samSecrets]
assert [signer.qb64 for signer in samSigners] == samSecrets
with basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="sam") as samDB, keeping.openKS(name="sam") as samKS, \
basing.openDB(name="wit") as witDB, keeping.openKS(name="wit") as witKS:
samPort = 5620 # sam's TCP listening port for server
witPort = 5621 # wit' TCP listneing port for server
# setup the witness
witHab = habbing.Habitat(name='Wit',
ks=witKS,
db=witDB,
isith=1,
icount=1,
temp=True,
transferable=False)
wit = witHab.pre
assert witHab.ks == witKS
assert witHab.db == witDB
witServer = serving.Server(host="", port=witPort)
witServerDoer = serving.ServerDoer(server=witServer)
witDirectant = directing.Directant(hab=witHab, server=witServer)
witDoers = [witServerDoer, witDirectant]
# setup cam
# cam inception transferable (nxt digest not empty)
camSerder = eventing.incept(
keys=[camSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[camSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
cam = camSerder.ked["i"]
assert cam == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
# sam inception transferable (nxt digest not empty)
samSerder = eventing.incept(
keys=[samSigners[0].verfer.qb64],
wits=[wit],
nxt=coring.Nexter(keys=[samSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
sam = samSerder.ked["i"]
assert sam == 'EhnaYUqhHoo8kZaXJuTDCZ-h5ZDx3st4NemgqSITWp48'
samHab = habbing.Habitat(name='Sam',
ks=samKS,
db=samDB,
wits=[wit],
secrecies=samSecrecies,
temp=True)
assert samHab.ks == samKS
assert samHab.db == samDB
assert samHab.iserder.dig == samSerder.dig
assert samHab.pre == sam
samClient = clienting.Client(host='127.0.0.1', port=witPort)
samClientDoer = clienting.ClientDoer(client=samClient)
samDirector = demoing.SamDirector(hab=samHab,
client=samClient,
tock=0.125)
assert samDirector.hab == samHab
assert samDirector.client == samClient
assert id(samDirector.hab.kvy.kevers) == id(samHab.kevers)
assert samDirector.hab.kvy.db == samDB
assert samDirector.tock == 0.125
samReactor = directing.Reactor(hab=samHab, client=samClient)
assert samReactor.hab == samHab
assert samReactor.client == samClient
assert id(samReactor.hab.kvy.kevers) == id(samHab.kevers)
assert samReactor.hab.kvy.db == samDB
assert samReactor.hab.psr.ims == samReactor.client.rxbs
samServer = serving.Server(host="", port=samPort)
samServerDoer = serving.ServerDoer(server=samServer)
samDirectant = directing.Directant(hab=samHab, server=samServer)
assert samDirectant.hab == samHab
assert samDirectant.server == samServer
# Sam's Reactants created on demand
samDoers = [
samClientDoer, samDirector, samReactor, samServerDoer, samDirectant
]
# setup cam
camHab = habbing.Habitat(name='Cam',
ks=camKS,
db=camDB,
secrecies=camSecrecies,
temp=True)
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.iserder.dig == camSerder.dig
assert camHab.pre == cam
camClient = clienting.Client(host='127.0.0.1', port=witPort)
camClientDoer = clienting.ClientDoer(client=camClient)
camDirector = demoing.CamDirector(hab=camHab,
remotePre=sam,
client=camClient,
tock=0.125)
assert camDirector.hab == camHab
assert camDirector.client == camClient
assert id(camDirector.hab.kvy.kevers) == id(camHab.kevers)
assert camDirector.hab.kvy.db == camDB
assert camDirector.tock == 0.125
camReactor = directing.Reactor(hab=camHab,
client=camClient,
indirect=True)
assert camReactor.hab == camHab
assert camReactor.client == camClient
assert id(camReactor.hab.kvy.kevers) == id(camHab.kevers)
assert camReactor.hab.kvy.db == camDB
assert camReactor.hab.psr.ims == camReactor.client.rxbs
camDoers = [camClientDoer, camDirector, camReactor]
# Manually stage SamDoers and wit doers and then camDoers
tock = 0.03125
doist = doing.Doist(doers=samDoers + witDoers, tock=tock)
# manually prep doers
doist.done = False
doist.enter() # injects doist.tymth() dependency to all doers
assert len(doist.deeds) == len(samDoers + witDoers)
while doist.tyme < doist.tock * 16:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers)
assert not doist.done
assert samHab.pre in samHab.kevers
# now start up cam doers
doist.extend(camDoers)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers)
while doist.tyme < doist.tock * 32:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers) - 1
# camDirector completes
assert camDirector.done
assert not doist.done
assert camHab.pre in camHab.kevers
assert samHab.pre in camHab.kevers
# verify final event states
doist.exit()
assert samClient.opened is False
assert samServer.opened is False
assert camClient.opened is False
assert not os.path.exists(camDB.path)
assert not os.path.exists(samDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_direct_mode_sam():
"""
Test direct mode demo
"""
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.CryOneDex.Blake3_256)
bob = bobSerder.ked['pre']
assert bob == 'ETT9n-TCGn8XfkGkcNeNmZgdZSwHPLyDsojFXotBXdSo'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.CryOneDex.Blake3_256)
eve = eveSerder.ked['pre']
assert eve == 'EwBwUb2eZcA5GDcN7g-87wpreM0nNkLqzkwviBHTcV1A'
with dbing.openLogger(name="eve") as eveDB, \
dbing.openLogger(name="bob") as bobDB:
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(secrets=bobSecrets,
kevers=bobKevers,
db=bobDB)
assert bobHab.db == bobDB
assert ([signer.verfer.qb64 for signer in bobHab.signers
] == [signer.verfer.qb64 for signer in bobSigners])
assert bobHab.inception.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(host='127.0.0.1', port=evePort)
bobClientDoer = doing.ClientDoer(client=bobClient)
bobDirector = directing.SamDirector(hab=bobHab,
client=bobClient,
tock=0.125)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert bobDirector.kevery.kevers == bobKevers
assert bobDirector.kevery.logger == bobDB
assert bobDirector.tock == 0.125
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert bobReactor.kevery.kevers == bobKevers
assert bobReactor.kevery.logger == bobDB
assert bobReactor.kevery.ims == bobReactor.client.rxbs
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(secrets=eveSecrets,
kevers=eveKevers,
db=eveDB)
assert eveHab.db == eveDB
assert ([signer.verfer.qb64 for signer in eveHab.signers
] == [signer.verfer.qb64 for signer in eveSigners])
assert eveHab.inception.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(host='127.0.0.1', port=bobPort)
eveClientDoer = doing.ClientDoer(client=eveClient)
eveDirector = directing.EveDirector(hab=eveHab,
client=eveClient,
tock=0.125)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert eveDirector.kevery.kevers == eveKevers
assert eveDirector.kevery.logger == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert eveReactor.kevery.kevers == eveKevers
assert eveReactor.kevery.logger == eveDB
assert eveReactor.kevery.ims == eveReactor.client.rxbs
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
limit = 1.0
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
#eveMsgTx = b"Hi Bob its me Eve"
#eveDirector.client.tx(eveMsgTx)
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert bobHab.pre in bobHab.kevers
assert eveHab.pre in eveHab.kevers
assert not bobClient.txes
assert bobHab.pre in eveHab.kevers
# verify final bob event state
# verify final val event state
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
"""End Test"""