def test_id():
"""Test get a random user_id"""
user_id1 = helper.user.id()
user_id2 = helper.user.id()
assert isinstance(user_id1, str)
assert isinstance(user_id2, str)
assert PUBLIC_KEY_PATTERN.match(user_id1)
assert PUBLIC_KEY_PATTERN.match(user_id2)
assert user_id1 != user_id2
def test_id(self):
"""Test get a random user_id"""
self.assertTrue(callable(self.test.user.id))
user_id1 = self.test.user.id()
user_id2 = self.test.user.id()
self.assertIsInstance(user_id1, str)
self.assertIsInstance(user_id2, str)
self.assertTrue(PUBLIC_KEY_PATTERN.match(user_id1))
self.assertTrue(PUBLIC_KEY_PATTERN.match(user_id2))
self.assertNotEqual(user_id1, user_id2)
def test_key():
"""Test get a generated keypair"""
key1 = helper.user.key()
key2 = helper.user.key()
assert isinstance(key1, Key)
assert isinstance(key2, Key)
assert PUBLIC_KEY_PATTERN.match(key1.public_key)
assert PUBLIC_KEY_PATTERN.match(key2.public_key)
assert PRIVATE_KEY_PATTERN.match(key1.private_key)
assert PRIVATE_KEY_PATTERN.match(key2.private_key)
assert key1.public_key != key2.public_key
assert key1.private_key != key2.private_key
def assertIsPublicKeyHex(self, key):
"""Sanity checks a hexidecimal string public key"""
self.assertIsInstance(key, str)
self.assertTrue(PUBLIC_KEY_PATTERN.match(key))
key = Secp256k1PublicKey.from_hex(key)
self.assertIsPublicKeySecp256k1(key)
return key
def base_validate_state(self, state, message, signer):
if signer is None:
raise ValueError("Signer is required")
if message is None:
raise ValueError("Message is required")
if not isinstance(signer, str) and PUBLIC_KEY_PATTERN.match(signer):
raise TypeError("Expected signer to be a public key")
if state is None:
raise ValueError("State is required")
def test_key_class_given_private_key(self):
"""Test initializing the key class with a given private key"""
private_key = Secp256k1PrivateKey.new_random()
txn_key = Key(private_key.as_hex())
self.assertEqual(len(txn_key.private_key), PRIVATE_KEY_LENGTH * 2)
self.assertTrue(PRIVATE_KEY_PATTERN.match(txn_key.private_key))
self.assertEqual(txn_key.private_key, private_key.as_hex())
self.assertEqual(len(txn_key.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertTrue(PUBLIC_KEY_PATTERN.match(txn_key.public_key))
def base_validate(self, message, signer=None):
if not isinstance(message, self.message_proto):
raise TypeError("Expected message to be {}".format(
self.message_proto))
if (signer is not None and not isinstance(signer, Key)
and not (isinstance(signer, str)
and PUBLIC_KEY_PATTERN.match(signer))):
raise TypeError("Expected signer to be a keypair or a public key")
if isinstance(signer, Key):
signer = signer.public_key
return signer
def test_key_class_random_keys(self):
value1 = Key()
value2 = Key()
self.assertTrue(isinstance(value1, Key))
self.assertTrue(isinstance(value2, Key))
self.assertNotEqual(value1, value2)
self.assertIsInstance(value1.public_key, str)
self.assertIsInstance(value2.public_key, str)
self.assertIsInstance(value1.private_key, str)
self.assertIsInstance(value2.private_key, str)
self.assertEqual(len(value1.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertEqual(len(value2.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertEqual(len(value1.private_key), PRIVATE_KEY_LENGTH * 2)
self.assertEqual(len(value2.private_key), PRIVATE_KEY_LENGTH * 2)
self.assertTrue(PUBLIC_KEY_PATTERN.match(value1.public_key))
self.assertTrue(PUBLIC_KEY_PATTERN.match(value2.public_key))
self.assertTrue(PRIVATE_KEY_PATTERN.match(value1.private_key))
self.assertTrue(PRIVATE_KEY_PATTERN.match(value2.private_key))
self.assertNotEqual(value1.public_key, value2.public_key)
self.assertNotEqual(value1.private_key, value2.private_key)
def test_key_class_random_keys(self):
"""Test the key class generates different keys each time initialized"""
value1 = Key()
value2 = Key()
self.assertTrue(isinstance(value1, Key))
self.assertTrue(isinstance(value2, Key))
self.assertNotEqual(value1, value2)
self.assertIsInstance(value1.public_key, str)
self.assertIsInstance(value2.public_key, str)
self.assertIsInstance(value1.private_key, str)
self.assertIsInstance(value2.private_key, str)
self.assertEqual(len(value1.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertEqual(len(value2.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertEqual(len(value1.private_key), PRIVATE_KEY_LENGTH * 2)
self.assertEqual(len(value2.private_key), PRIVATE_KEY_LENGTH * 2)
self.assertTrue(PUBLIC_KEY_PATTERN.match(value1.public_key))
self.assertTrue(PUBLIC_KEY_PATTERN.match(value2.public_key))
self.assertTrue(PRIVATE_KEY_PATTERN.match(value1.private_key))
self.assertTrue(PRIVATE_KEY_PATTERN.match(value2.private_key))
self.assertNotEqual(value1.public_key, value2.public_key)
self.assertNotEqual(value1.private_key, value2.private_key)
def assertIsPublicKeySecp256k1(self, key):
"""Sanity checks a Secp256k1PublicKey public key"""
self.assertIsInstance(key, Secp256k1PublicKey)
self.assertIsInstance(key.as_hex(), str)
self.assertEqual(len(key.as_hex()), PUBLIC_KEY_LENGTH * 2)
self.assertTrue(PUBLIC_KEY_PATTERN.match(key.as_hex()))
self.assertIsInstance(key.as_bytes(), bytes)
self.assertEqual(len(key.as_bytes()), PUBLIC_KEY_LENGTH)
self.assertEqual(key.as_hex(),
str(binascii.hexlify(key.as_bytes()), "ascii"))
self.assertEqual(binascii.unhexlify(key.as_hex()), key.as_bytes())
return key
def validate_state(self, context, message, inputs, input_state, store, signer):
"""Common state validation for all messages"""
if signer is None:
raise ValueError("Signer is required")
if message is None:
raise ValueError("Message is required")
if not isinstance(inputs, list) and not isinstance(inputs, set):
raise ValueError("Inputs is required and expected to be a list or a set")
if not isinstance(input_state, dict):
raise ValueError("Input state was expecte to be a dictionary")
if not isinstance(signer, str) and PUBLIC_KEY_PATTERN.match(signer):
raise TypeError("Expected signer to be a public key")
if context is None:
raise ValueError("State context is required")
def validate_state(self, context, message, payload, input_state, store):
"""Common state validation for all messages"""
if payload.signer.public_key is None:
raise ValueError("Signer public key is required")
if payload.signer.user_id is None:
raise ValueError("Signer user id is required")
if message is None:
raise ValueError("Message is required")
if not isinstance(payload.inputs, (list, set)):
raise ValueError("Inputs is required and expected to be a list or a set")
if not isinstance(input_state, dict):
raise ValueError("Input state was expected to be a dictionary")
if not isinstance(payload.signer.public_key, str) and PUBLIC_KEY_PATTERN.match(
payload.signer.public_key
):
raise TypeError("Expected signer public key to be a public key")
if context is None:
raise ValueError("State context is required")
def test_key_class_public_key(self):
private_key = Secp256k1PrivateKey.new_random()
txn_key = Key(private_key.as_hex())
self.assertEqual(len(txn_key.public_key), PUBLIC_KEY_LENGTH * 2)
self.assertTrue(PUBLIC_KEY_PATTERN.match(txn_key.public_key))