def test_store_del(self, mock_lmdb):
"""Verify that del removes entries from the store
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Delete from an empty store
del store['ppk_1']
# Set some values, do some deletes and verify store state is valid
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False)
store['ppk_2'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_2').decode(),
has_been_refreshed=False)
del store['ppk_1']
self.assertFalse('ppk_1' in store)
self.assertTrue('ppk_2' in store)
del store['ppk_2']
self.assertFalse('ppk_2' in store)
# Delete already deleted keys
del store['ppk_1']
self.assertFalse('ppk_1' in store)
self.assertFalse('ppk_2' in store)
def test_store_contains(self, mock_lmdb):
"""Verify that in, i.e., key in store, returns correct values
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Verify empty store
self.assertFalse('ppk_1' in store)
# Set some values and verify that store has keys
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False)
self.assertTrue('ppk_1' in store)
store['ppk_2'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_2').decode(),
has_been_refreshed=False)
self.assertTrue('ppk_1' in store)
self.assertTrue('ppk_2' in store)
# Delete values and verify that store does not have keys
del store['ppk_2']
self.assertFalse('ppk_2' in store)
self.assertTrue('ppk_1' in store)
del store['ppk_1']
self.assertFalse('ppk_1' in store)
self.assertFalse('ppk_2' in store)
def test_store_len(self, mock_lmdb):
"""Verify that len() returns correct values for store.
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Verify that an empty database returns 0
self.assertEqual(len(store), 0)
# Set some values and verify that the length reflects it
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False)
self.assertEqual(len(store), 1)
store['ppk_2'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_2').decode(),
has_been_refreshed=False)
self.assertEqual(len(store), 2)
# Delete values and verify that the length reflects it
del store['ppk_1']
self.assertEqual(len(store), 1)
del store['ppk_1']
self.assertEqual(len(store), 1)
del store['ppk_2']
self.assertEqual(len(store), 0)
def test_store_iter(self, mock_lmdb):
"""Verify that iterating over store, i.e., for key in store:, iterates
over all keys.
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Verify empty store
iterated_ppks = []
for ppk in store:
iterated_ppks.append(ppk)
self.assertEqual(len(iterated_ppks), 0)
# Add some keys and verify iteration
ppks = ['ppk_1', 'ppk_2', 'ppk_3', 'ppk_4']
for ppk in ppks:
store[ppk] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(
'sealed for {}'.format(ppk).encode()).decode(),
has_been_refreshed=False,
signup_nonce='single-use-only')
iterated_ppks = []
for ppk in store:
iterated_ppks.append(ppk)
self.assertEqual(len(iterated_ppks), len(store))
self.assertEqual(sorted(iterated_ppks), sorted(ppks))
# Delete some keys and verify iteration
ppks.remove('ppk_1')
del store['ppk_1']
ppks.remove('ppk_3')
del store['ppk_3']
iterated_ppks = []
for ppk in store:
iterated_ppks.append(ppk)
self.assertEqual(len(iterated_ppks), len(store))
self.assertEqual(sorted(iterated_ppks), sorted(ppks))
# Delete remaining keys and verify iteration
ppks.remove('ppk_2')
del store['ppk_2']
ppks.remove('ppk_4')
del store['ppk_4']
iterated_ppks = []
for ppk in store:
iterated_ppks.append(ppk)
self.assertEqual(len(iterated_ppks), 0)
def test_store_set_get(self, mock_lmdb):
"""Verify that retrieving a previously set PoET public key results in
the same value set.
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Store a key and verify that returns correct value
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False,
signup_nonce='single-use-only')
poet_key_state = store['ppk_1']
self.assertEqual(poet_key_state.sealed_signup_data,
base64.b64encode(b'sealed_1').decode())
self.assertFalse(poet_key_state.has_been_refreshed)
# Store another key and verify that returns correct value
store['ppk_2'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_2').decode(),
has_been_refreshed=True,
signup_nonce='single-use-only')
poet_key_state = store['ppk_2']
self.assertEqual(poet_key_state.sealed_signup_data,
base64.b64encode(b'sealed_2').decode())
self.assertTrue(poet_key_state.has_been_refreshed)
poet_key_state = store['ppk_1']
self.assertEqual(poet_key_state.sealed_signup_data,
base64.b64encode(b'sealed_1').decode())
self.assertFalse(poet_key_state.has_been_refreshed)
# Delete a key and verify that existing key still returns correct
# value
del store['ppk_1']
poet_key_state = store['ppk_2']
self.assertEqual(poet_key_state.sealed_signup_data,
base64.b64encode(b'sealed_2').decode())
self.assertTrue(poet_key_state.has_been_refreshed)
def test_store_set_invalid_data(self, mock_lmdb):
"""Verify that attempting to set invalid data fails
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
# Store a non-PoetKeyState object
for poet_key_state in [[], {}, (), 1, 1.0, '', False]:
with self.assertRaises(ValueError):
store['ppk_1'] = poet_key_state
# Store invalid sealed_signup_data field
for sealed_signup_data in [[], {}, (), 1, 1.0, b'', True]:
with self.assertRaises(ValueError):
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=sealed_signup_data,
has_been_refreshed=False,
signup_nonce='single-use-only')
# Store corrupted base64 sealed signup data
with self.assertRaises(ValueError):
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(
b'sealed_1').decode()[1:],
has_been_refreshed=False,
signup_nonce='single-use-only')
# Store non-bool has_been_refreshed field
sealed_signup_data = base64.b64encode(b'sealed').decode()
for has_been_refreshed in [[], {}, (), 1, 1.0, '']:
with self.assertRaises(ValueError):
store['ppk_1'] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=sealed_signup_data,
has_been_refreshed=has_been_refreshed,
signup_nonce='single-use-only')
def test_active_key_present(self, mock_lmdb):
"""Verify that setting a present key active succeeds
"""
mock_lmdb.return_value = {
'ppk_1':
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False)
}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
store.active_key = 'ppk_1'
self.assertEqual(store.active_key, 'ppk_1')
def test_store_poet_public_keys(self, mock_lmdb):
"""Verify that poet_public_keys property returns a list of the expected
keys.
"""
# Make LMDB return empty dict
mock_lmdb.return_value = {}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
self.assertEqual(len(store.poet_public_keys), 0)
# Add some keys and verify
ppks = ['ppk_1', 'ppk_2', 'ppk_3', 'ppk_4']
for ppk in ppks:
store[ppk] = \
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(
'sealed for {}'.format(ppk).encode()).decode(),
has_been_refreshed=False,
signup_nonce='single-use-only')
self.assertEqual(len(store.poet_public_keys), len(ppks))
self.assertEqual(sorted(ppks), sorted(store.poet_public_keys))
# Delete some keys and verify
ppks.remove('ppk_1')
del store['ppk_1']
ppks.remove('ppk_3')
del store['ppk_3']
self.assertEqual(len(store.poet_public_keys), len(ppks))
self.assertEqual(sorted(ppks), sorted(store.poet_public_keys))
# Delete remaining keys and verify
ppks.remove('ppk_2')
del store['ppk_2']
ppks.remove('ppk_4')
del store['ppk_4']
self.assertEqual(len(store.poet_public_keys), 0)
def test_active_key_delete(self, mock_lmdb):
"""Verify that deleting the key state for the active key also clears
the active key
"""
mock_lmdb.return_value = {
'ppk_1':
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False)
}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
store.active_key = 'ppk_1'
self.assertEqual(store.active_key, 'ppk_1')
del store['ppk_1']
self.assertIsNone(store.active_key)
def test_active_key_clear(self, mock_lmdb):
"""Verify that clearing the active succeeds
"""
mock_lmdb.return_value = {
'ppk_1':
poet_key_state_store.PoetKeyState(
sealed_signup_data=base64.b64encode(b'sealed_1').decode(),
has_been_refreshed=False,
signup_nonce='single-use-only')
}
store = \
poet_key_state_store.PoetKeyStateStore(
data_dir=tempfile.gettempdir(),
validator_id='0123456789abcdef')
store.active_key = 'ppk_1'
self.assertEqual(store.active_key, 'ppk_1')
store.active_key = None
self.assertIsNone(store.active_key)
