def test_generated_user_address(self):
"""Tests the Users address creation function as well as the
address_is function.
"""
ident = uuid4().hex
address = addresser.make_user_address(ident)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(
addresser.address_is(address),
AddressSpace.USER,
"The address created must be found to be a User address.",
)
def test_gen_proposal_addr(self):
"""Tests the proposal address creation function as well as the
address_is function.
"""
object_id = uuid4().hex
related_id = uuid4().hex
address = addresser.make_proposal_address(object_id, related_id)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(
addresser.address_is(address),
AddressSpace.PROPOSALS,
"The address created must be a Proposal address.",
)
def test_deterministic_user_address(self):
"""Tests that a specific user_id generates the expected
user address, and thus is probably deterministic.
"""
ident = "966ab67317234df489adb4bc1f517b88"
expected_address = "9f444847e7570f3f6f7d2c1635f6de\
eabc1f4d78d9d42b64b70e1819f244138c1e38d6"
address = addresser.make_user_address(ident)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(address, expected_address,
"The address is the one we expected it to be")
self.assertEqual(
addresser.address_is(address),
AddressSpace.USER,
"The User address created must be found to be a User address.",
)
def test_determine_proposal_addr(self):
"""Tests that a specific proposal_id generates the expected
proposal address, and thus is probably deterministic.
"""
object_id = "cb048d507eec42a5845e20eed982d5d2"
related_id = "f1e916b663164211a9ac34516324681a"
expected_address = "9f4448e3b874e90b2bcf58e65e0727\
91ea499543ee52fc9d0449fc1e41f77d4d4f926e"
address = addresser.make_proposal_address(object_id, related_id)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(address, expected_address,
"The address is the one we expected it to be")
self.assertEqual(
addresser.address_is(address),
AddressSpace.PROPOSALS,
"The address created must be a Proposal address.",
)
def test_generated_role_address(self):
"""Tests the role address creation function as well as the
address_is function.
"""
ident = uuid4().hex
address = addresser.make_role_attributes_address(ident)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(
addresser.address_is(address),
AddressSpace.ROLES_ATTRIBUTES,
"The address created must be a Role Attributes address.",
)
def test_deterministic_role_address(self):
"""Tests that a specific role_id generates the expected
role address, and thus is probably deterministic.
"""
ident = "99968acb8f1a48b3a4bc21e2cd252e67"
expected_address = "9f444809326a1713a905b26359fc8d\
a2817c1a5f67de6f464701f0c10042da345d2800"
address = addresser.make_role_attributes_address(ident)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH,
"The address is 70 characters")
self.assertTrue(addresser.is_address(address),
"The address is 70 character hexidecimal")
self.assertTrue(addresser.namespace_ok(address),
"The address has correct namespace prefix")
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(address, expected_address,
"The address is the one we expected it to be")
self.assertEqual(
addresser.address_is(address),
AddressSpace.ROLES_ATTRIBUTES,
"The address created must be a Role Attributes address.",
)
def test_nonhex_address(self):
"""Tests that an address that is not hex does not validate.
"""
address = "9f444847e7570f3f6f7d2c1635f6de\
eabc1f4d78d9d42b64b70e1819f244138c1e38X6"
self.assertFalse(addresser.is_address(address),
"The address is not 70 character hexidecimal")
self.assertFalse(
addresser.is_family_address(address),
"The address is not 70 character hexidecimal with family prefix",
)
with self.assertRaises(ValueError):
addresser.address_is(address)
def assertValidInputs(self, inputs, outputs, message_type, message=None):
if inputs is not None and not isinstance(inputs, list):
inputs = list(inputs)
if outputs is not None and not isinstance(outputs, list):
outputs = list(outputs)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(inputs, list)
self.assertIsInstance(outputs, list)
self.assertEqual(len(inputs), 1)
self.assertEqual(len(outputs), 1)
self.assertEqual(addresser.address_is(inputs[0]), AddressSpace.USER)
self.assertEqual(addresser.address_is(outputs[0]), AddressSpace.USER)
else:
raise Exception(
"assertValidInputs doesn't yet support {}".format(message_type)
)
def return_state(self):
items = []
for item in self._client.list_state(subtree=addresser.NS)["data"]:
if addresser.address_is(
item["address"]) == addresser.AddressSpace.USER:
user_container = user_state_pb2.UserContainer()
user_container.ParseFromString(b64decode(item["data"]))
items.append((user_container, addresser.AddressSpace.USER))
return items
def assertValidInputs(self, inputs, outputs, message_type, message=None):
"""Check the inputs and outputs match the expected message type"""
if inputs is not None and not isinstance(inputs, list):
inputs = list(inputs)
if outputs is not None and not isinstance(outputs, list):
outputs = list(outputs)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(inputs, list)
self.assertIsInstance(outputs, list)
self.assertEqual(len(inputs), 1)
self.assertEqual(len(outputs), 1)
self.assertEqual(addresser.address_is(inputs[0]),
AddressSpace.USER)
self.assertEqual(addresser.address_is(outputs[0]),
AddressSpace.USER)
else:
raise Exception(
"BatchAssertions.assertValidInputs doesn't support message_type {}"
.format(message_type))
def data_to_dicts(address, data):
"""Deserializes a protobuf binary based on its address. Returns a list of
the decoded objects which were stored at that address.
"""
data_type = address_is(address)
try:
deserializer = DESERIALIZERS[data_type]
except KeyError:
raise TypeError("Unknown data type: {}".format(data_type))
return [_proto_to_dict(pb) for pb in deserializer(data)]
def test_long_address(self):
"""Tests that an address that is too long does not validate.
"""
address = "9f444847e7570f3f6f7d2c1635f6de\
eabc1f4d78d9d42b64b70e1819f244138c1e38d6fe"
self.assertFalse(
len(address) == addresser.ADDRESS_LENGTH,
"The address is not 70 characters")
self.assertFalse(addresser.is_address(address),
"The address is not 70 character hexidecimal")
self.assertFalse(
addresser.is_family_address(address),
"The address is not 70 character hexidecimal with family prefix",
)
with self.assertRaises(ValueError):
addresser.address_is(address)
def test_state(self):
subtree = addresser.NS
for item in self.client.list_state(subtree=subtree)["data"]:
address_type = item["address_type"] = addresser.address_is(item["address"])
if address_type == AddressSpace.USER:
content = user_state_pb2.UserContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.PROPOSALS:
content = proposal_state_pb2.ProposalsContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.SYSADMIN_ATTRIBUTES:
content = "SYSADMIN_ATTRIBUTES"
elif address_type == AddressSpace.SYSADMIN_MEMBERS:
content = "SYSADMIN_MEMBERS"
elif address_type == AddressSpace.SYSADMIN_OWNERS:
content = "SYSADMIN_OWNERS"
elif address_type == AddressSpace.SYSADMIN_ADMINS:
content = "SYSADMIN_ADMINS"
elif address_type == AddressSpace.ROLES_ATTRIBUTES:
content = role_state_pb2.RoleAttributesContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.ROLES_MEMBERS:
content = role_state_pb2.RoleRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.ROLES_OWNERS:
content = role_state_pb2.RoleRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.ROLES_ADMINS:
content = role_state_pb2.RoleRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.ROLES_TASKS:
content = role_state_pb2.RoleRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.TASKS_ATTRIBUTES:
content = task_state_pb2.TaskAttributesContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.TASKS_OWNERS:
content = task_state_pb2.TaskRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
elif address_type == AddressSpace.TASKS_ADMINS:
content = task_state_pb2.TaskRelationshipContainer()
content.ParseFromString(b64decode(item["data"]))
else:
content = "ERROR: unknown type: {}".format(address_type)
LOGGER.debug("%-80s%-30s%s", item["address"], address_type, content)
def test_users_address(self):
"""Tests the Users address creation function as well as the
address_is function.
Notes:
1. Create a Users address.
2. Assert that address_is returns the correct address type.
"""
users_address = addresser.make_user_address(user_id=uuid4().hex)
self.assertEqual(
len(users_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(users_address),
AddressSpace.USER,
"The User address created must be found " "to be a User address.",
)
def _update(database, block_num, address, resource):
data_type = address_is(address)
resource["start_block_num"] = block_num
resource["end_block_num"] = str(sys.maxsize)
if ADD_SUFFIX.get(data_type, False):
resource["suffix"] = int(address[-2:], 16)
try:
table_query = database.get_table(TABLE_NAMES[data_type])
update_filter = {k: resource[k] for k in FILTER_KEYS[data_type]}
except KeyError:
raise TypeError("Unknown data type: {}".format(data_type))
update_filter["end_block_num"] = str(sys.maxsize)
query = (table_query.filter(update_filter).update({
"end_block_num":
block_num
}).merge(table_query.insert(resource).without("replaced")))
return database.run_query(query)
def test_proposal_addresses(self):
"""Tests the Proposal address creation function as well as the
address_is function.
Notes:
1. Create a Proposal address.
2. Assert that address_is returns the correct address type.
"""
proposal_address = addresser.make_proposal_address(
object_id=uuid4().hex, related_id=uuid4().hex)
self.assertEqual(len(proposal_address), 70,
"The address is a well-formed address.")
self.assertEqual(
addresser.address_is(proposal_address),
AddressSpace.PROPOSALS,
"The Proposals address created must be found "
"to be a Proposals address.",
)
def test_determine_task_admin_addr(self):
"""Tests that a specific task_id and admin_id generates the
expected task admin address, and thus is probably deterministic.
"""
task_id = "99968acb8f1a48b3a4bc21e2cd252e67"
admin_id = "966ab67317234df489adb4bc1f517b88"
expected_address = "9f44481e326a1713a905b26359fc8d\
a2817c1a5f67de6f464701f0c10042da345d2848"
address = addresser.make_task_admins_address(task_id, admin_id)
self.assertEqual(
len(address), addresser.ADDRESS_LENGTH, "The address is 70 characters"
)
self.assertTrue(
addresser.is_address(address), "The address is 70 character hexidecimal"
)
self.assertTrue(
addresser.namespace_ok(address), "The address has correct namespace prefix"
)
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(
address, expected_address, "The address is the one we expected it to be"
)
self.assertEqual(
addresser.address_is(address),
AddressSpace.TASKS_ADMINS,
"The address created must be a Task Attributes address.",
)
def test_determine_role_member_addr(self):
"""Tests that a specific role_id and member_id generates the
expected role member address, and thus is probably deterministic.
"""
role_id = "99968acb8f1a48b3a4bc21e2cd252e67"
member_id = "966ab67317234df489adb4bc1f517b88"
expected_address = "9f444809326a1713a905b26359fc8d\
a2817c1a5f67de6f464701f0c10042da345d2833"
address = addresser.make_role_members_address(role_id, member_id)
self.assertEqual(
len(address), addresser.ADDRESS_LENGTH, "The address is 70 characters"
)
self.assertTrue(
addresser.is_address(address), "The address is 70 character hexidecimal"
)
self.assertTrue(
addresser.namespace_ok(address), "The address has correct namespace prefix"
)
self.assertTrue(
addresser.is_family_address(address),
"The address is 70 character hexidecimal with family prefix",
)
self.assertEqual(
address, expected_address, "The address is the one we expected it to be"
)
self.assertEqual(
addresser.address_is(address),
AddressSpace.ROLES_MEMBERS,
"The address created must be a Role Attributes address.",
)
def test_sysadmin_addresses(self):
"""Tests the SysAdmin address creation functions as well as the
address_is function.
Notes:
1. Create a SysAdmin address.
- SysAdmin Attributes
- SysAdmin Members
- SysAdmin Owners
- SysAdmin Admins
2. Assert that the address_is function returns the correct
address type.
"""
sysadmin_address = addresser.make_sysadmin_attr_address()
self.assertEqual(
len(sysadmin_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(sysadmin_address),
AddressSpace.SYSADMIN_ATTRIBUTES,
"The SysAdmin Attributes address created must be found "
"to be a SysAdmin Attributes address.",
)
sysadmin_members_address = addresser.make_sysadmin_members_address(
user_id=uuid4().hex
)
self.assertEqual(
len(sysadmin_members_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(sysadmin_members_address),
AddressSpace.SYSADMIN_MEMBERS,
"The SysAdmin Members address created must be found to "
"be a SysAdmin Members address.",
)
sysadmin_owners_address = addresser.make_sysadmin_owners_address(
user_id=uuid4().hex
)
self.assertEqual(
len(sysadmin_owners_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(sysadmin_owners_address),
AddressSpace.SYSADMIN_OWNERS,
"The SysAdmin Owners address created must be found to "
"be a SysAdmin Owners address.",
)
sysadmin_admins_address = addresser.make_sysadmin_admins_address(
user_id=uuid4().hex
)
self.assertEqual(
len(sysadmin_admins_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(sysadmin_admins_address),
AddressSpace.SYSADMIN_ADMINS,
"The SysAdmin Admins address created must be found to "
"be a SysAdmin Admins address.",
)
def create_user_transaction(self, name, username, metadata):
txn_private_key = Secp256k1PrivateKey.new_random()
batch_private_key = Secp256k1PrivateKey.new_random()
txn_key = Key(txn_private_key.as_hex())
batch_key = Key(batch_private_key.as_hex())
batchlist, sig = create_user(
txn_key, batch_key, name, username, txn_key.public_key, metadata
)
self.assertEqual(type(sig), str)
self.assertEqual(type(batchlist), batch_pb2.BatchList)
self.assertEqual(len(sig), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(sig))
batch_count = 0
for batch in batchlist.batches:
batch_count += 1
self.assertEqual(type(batch), batch_pb2.Batch)
self.assertEqual(type(batch.header_signature), str)
self.assertEqual(len(batch.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(batch.header_signature))
trans_count = 0
for transaction in batch.transactions:
trans_count += 1
self.assertEqual(type(transaction.header), bytes)
self.assertEqual(type(transaction.header_signature), str)
self.assertEqual(type(transaction.payload), bytes)
self.assertEqual(len(transaction.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(transaction.header_signature))
header = transaction_pb2.TransactionHeader()
header.ParseFromString(transaction.header)
self.assertEqual(type(header), transaction_pb2.TransactionHeader)
self.assertEqual(header.family_name, addresser.FAMILY_NAME)
self.assertEqual(header.family_version, addresser.FAMILY_VERSION)
self.assertEqual(header.batcher_public_key, batch_key.public_key)
self.assertEqual(header.signer_public_key, txn_key.public_key)
self.assertEqual(len(header.payload_sha512), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(header.payload_sha512))
input_count = 0
for address in header.inputs:
input_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertTrue(addresser.is_address(address))
self.assertTrue(addresser.namespace_ok(address))
self.assertTrue(addresser.is_family_address(address))
self.assertEqual(addresser.address_is(address), AddressSpace.USER)
self.assertEqual(input_count, 1)
output_count = 0
for address in header.outputs:
output_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertTrue(addresser.is_address(address))
self.assertTrue(addresser.namespace_ok(address))
self.assertTrue(addresser.is_family_address(address))
self.assertEqual(addresser.address_is(address), AddressSpace.USER)
self.assertEqual(output_count, 1)
payload = rbac_payload_pb2.RBACPayload()
payload.ParseFromString(transaction.payload)
self.assertEqual(type(payload), rbac_payload_pb2.RBACPayload)
self.assertEqual(
payload.message_type, rbac_payload_pb2.RBACPayload.CREATE_USER
)
self.assertEqual(type(payload.content), bytes)
user = user_transaction_pb2.CreateUser()
user.ParseFromString(payload.content)
self.assertEqual(type(user), user_transaction_pb2.CreateUser)
self.assertEqual(user.name, name)
self.assertEqual(user.user_name, username)
self.assertEqual(type(user.user_id), str)
self.assertEqual(user.user_id, txn_key.public_key)
self.assertEqual(trans_count, 1)
self.assertEqual(batch_count, 1)
def test_role_addresses(self):
"""Tests the Role address creation functions as well as the
address_is function.
Notes:
1. Create an address of a particular type:
- Role Attributes
- Role Members
- Role Owners
- Role Admins
- Role Tasks
2. Assert that address_is returns the correct address type.
"""
role_address = addresser.make_role_attributes_address(role_id=uuid4().hex)
self.assertEqual(len(role_address), 70, "The address is a well-formed address.")
self.assertEqual(
addresser.address_is(role_address),
AddressSpace.ROLES_ATTRIBUTES,
"The Role Attributes address created must "
"be found to be a Role Attributes address.",
)
role_members_address = addresser.make_role_members_address(
role_id=uuid4().hex, user_id=uuid4().hex
)
self.assertEqual(
len(role_members_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(role_members_address),
AddressSpace.ROLES_MEMBERS,
"The Role Members address created must be "
"found to be a Role Members address.",
)
role_owners_address = addresser.make_role_owners_address(
role_id=uuid4().hex, user_id=uuid4().hex
)
self.assertEqual(
len(role_owners_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(role_owners_address),
AddressSpace.ROLES_OWNERS,
"The Role Owners address created must be found to be "
"a Role Members address.",
)
role_admins_address = addresser.make_role_admins_address(
role_id=uuid4().hex, user_id=uuid4().hex
)
self.assertEqual(
len(role_admins_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(role_admins_address),
AddressSpace.ROLES_ADMINS,
"The Role Admins address created must be "
"found to be a Role Admins address.",
)
role_tasks_address = addresser.make_role_tasks_address(
role_id=uuid4().hex, task_id=uuid4().hex
)
self.assertEqual(
len(role_tasks_address), 70, "The address is a well-formed address."
)
self.assertEqual(
addresser.address_is(role_tasks_address),
AddressSpace.ROLES_TASKS,
"The Role Tasks address created must be "
"found to be a Role Tasks address.",
)
