def test_addressing_user_key():
"""Tests making a blockchain address that is a user-key assignment:
1. is a 35-byte non-zero hexadecimal string
2. is unique - a different public user-key yields a different address
3. is deterministic - same public user-key yields same address
4. the addresser recognizes the address as a user-key
5. the addresser can parse the address into its components
6. the identifier is a hash of the user id
7. the related identifier is a hash of the public key
"""
key = helper.user.key().public_key
user_id = helper.user.id()
address = addresser.user.key.address(user_id, key)
assert assert_is_address(address)
assert address != addresser.user.key.address(user_id,
helper.user.key().public_key)
assert address != addresser.user.key.address(helper.user.id(), key)
assert address == addresser.user.key.address(user_id, key)
assert addresser.get_address_type(
address) == addresser.AddressSpace.USER_KEY
assert addresser.get_address_type(
address) == addresser.AddressSpace.USER_KEY
parsed = addresser.parse(address)
assert parsed.object_type == addresser.ObjectType.USER
assert parsed.related_type == addresser.ObjectType.KEY
assert parsed.relationship_type == addresser.RelationshipType.OWNER
assert assert_is_identifier(parsed.object_id)
assert parsed.object_id == addresser.user.hash(user_id)
assert parsed.related_id == addresser.key.hash(key)
def test_addressing_key():
"""Tests making a blockchain address for a public key and that it:
1. is a 35-byte non-zero hexadecimal string
2. is unique - a different public key yields a different address
3. is deterministic - same public key yields same address
4. the addresser recognizes the address as a public key
5. the addresser can parse the address into its components
6. the identifier is a hash of the public key"""
key = helper.user.key().public_key
address = addresser.key.address(key)
assert assert_is_address(address)
assert address != addresser.key.address(helper.user.key().public_key)
assert address == addresser.key.address(key)
assert address == addresser.key.address(key.upper())
assert addresser.get_address_type(address) == addresser.AddressSpace.KEY
assert addresser.get_address_type(address) == addresser.AddressSpace.KEY
parsed = addresser.parse(address)
assert parsed.object_type == addresser.ObjectType.KEY
assert parsed.related_type == addresser.ObjectType.NONE
assert parsed.relationship_type == addresser.RelationshipType.NONE
assert assert_is_identifier(parsed.object_id)
assert not parsed.related_id
assert parsed.object_id == addresser.key.hash(key)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
user_id1 = addresser.user.unique_id()
user_id2 = addresser.user.unique_id()
user_address1 = addresser.user.address(user_id1)
user_address2 = addresser.user.address(user_id2)
self.assertIsAddress(user_address1)
self.assertIsAddress(user_address2)
self.assertNotEqual(user_address1, user_address2)
self.assertEqual(addresser.get_address_type(user_address1),
addresser.AddressSpace.USER)
self.assertEqual(addresser.get_address_type(user_address2),
addresser.AddressSpace.USER)
def test_get_address_type(self):
"""Tests that get_address_type returns AddressSpace.USER if it is a user
address, and None if it is of another address type"""
user_address = addresser.user.address(addresser.user.unique_id())
role_address = addresser.role.address(addresser.role.unique_id())
self.assertEqual(addresser.get_address_type(user_address),
addresser.AddressSpace.USER)
self.assertEqual(addresser.user.get_address_type(user_address),
addresser.AddressSpace.USER)
self.assertIsNone(addresser.user.get_address_type(role_address))
self.assertEqual(
addresser.get_address_type(role_address),
addresser.AddressSpace.ROLES_ATTRIBUTES,
)
def test_get_test_inputs(self):
"""Verifies the test data inputs function returns the expected test data"""
message, message_type, inputs, outputs, signer = self.get_test_inputs()
self.assertIsInstance(signer, Key)
self.assertEqual(message_type, RBACPayload.CREATE_USER)
self.assertIsInstance(message, user_transaction_pb2.CreateUser)
self.assertIsInstance(message.name, str)
self.assertIsInstance(inputs, list)
self.assertIsInstance(outputs, list)
self.assertEqual(len(inputs), 1)
self.assertEqual(len(outputs), 1)
self.assertEqual(addresser.get_address_type(inputs[0]),
addresser.AddressSpace.USER)
self.assertEqual(addresser.get_address_type(outputs[0]),
addresser.AddressSpace.USER)
def test_addressing_email():
"""Tests making a blockchain address for an email and that it:
1. is a 35-byte non-zero hexadecimal string
2. is unique - a different email yields a different address
3. is deterministic - same email yields same address, even if different case
4. the addresser recognizes the address as an email
5. the addresser can parse the address into its components
6. the identifier is a hash of the email"""
email = helper.user.email()
address = addresser.email.address(email)
assert assert_is_address(address)
assert address != addresser.email.address(helper.user.email())
assert address == addresser.email.address(email)
assert address == addresser.email.address(email.upper())
assert addresser.get_address_type(address) == addresser.AddressSpace.EMAIL
parsed = addresser.parse(address)
assert parsed.object_type == addresser.ObjectType.EMAIL
assert parsed.related_type == addresser.ObjectType.NONE
assert parsed.relationship_type == addresser.RelationshipType.NONE
assert assert_is_identifier(parsed.object_id)
assert not parsed.related_id
assert parsed.object_id == addresser.email.hash(email)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
user_id = addresser.user.unique_id()
user_address = addresser.user.address(user_id)
self.assertIsAddress(user_address)
self.assertEqual(addresser.get_address_type(user_address),
addresser.AddressSpace.USER)
def _update_legacy(database, block_num, address, resource):
try:
data_type = addresser.get_address_type(address)
if data_type in TABLE_NAMES:
data = {
"id": address,
"start_block_num": int(block_num),
"end_block_num": int(sys.maxsize),
**resource,
}
table_query = database.get_table(TABLE_NAMES[data_type])
query = table_query.get(address).replace(lambda doc: r.branch(
# pylint: disable=singleton-comparison
(doc == None), # noqa
r.expr(data),
doc.merge(resource),
))
result = database.run_query(query)
if (not result["inserted"]
and not result["replaced"]) or result["errors"] > 0:
LOGGER.warning("error updating legacy state table:\n%s\n%s",
result, query)
except Exception as err: # pylint: disable=broad-except
LOGGER.warning("_update_legacy %s error:", type(err))
LOGGER.warning(err)
def test_addressing_user():
"""Tests making a blockchain address for an next_id and that it:
1. is a 35-byte non-zero hexadecimal string
2. is unique - a different next_id yields a different address
3. is deterministic - same next_id yields same address, even if different case
4. the addresser recognizes the address as an next_id
5. the addresser can parse the address into its components
6. the identifier is a hash of the next_id"""
next_id = helper.user.id()
address = addresser.user.address(next_id)
assert assert_is_address(address)
assert address != addresser.user.address(helper.user.id())
assert address == addresser.user.address(next_id)
assert address == addresser.user.address(next_id.upper())
assert addresser.get_address_type(address) == addresser.AddressSpace.USER
parsed = addresser.parse(address)
assert parsed.object_type == addresser.ObjectType.USER
assert parsed.related_type == addresser.ObjectType.NONE
assert parsed.relationship_type == addresser.RelationshipType.ATTRIBUTES
assert assert_is_identifier(parsed.object_id)
assert not parsed.related_id
assert parsed.object_id == addresser.user.hash(next_id)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
task_id1 = addresser.task.unique_id()
task_id2 = addresser.task.unique_id()
task_address1 = addresser.task.address(object_id=task_id1)
task_address2 = addresser.task.address(object_id=task_id2)
self.assertIsAddress(task_address1)
self.assertIsAddress(task_address2)
self.assertNotEqual(task_address1, task_address2)
self.assertEqual(
addresser.get_address_type(task_address1),
addresser.AddressSpace.TASKS_ATTRIBUTES,
)
self.assertEqual(
addresser.get_address_type(task_address2),
addresser.AddressSpace.TASKS_ATTRIBUTES,
)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
role_id1 = addresser.role.task.unique_id()
task_id1 = addresser.task.unique_id()
role_id2 = addresser.role.task.unique_id()
task_id2 = addresser.task.unique_id()
rel_address1 = addresser.role.task.address(object_id=role_id1,
related_id=task_id1)
rel_address2 = addresser.role.task.address(object_id=role_id2,
related_id=task_id2)
self.assertIsAddress(rel_address1)
self.assertIsAddress(rel_address2)
self.assertNotEqual(rel_address1, rel_address2)
self.assertEqual(addresser.get_address_type(rel_address1),
addresser.AddressSpace.ROLES_TASKS)
self.assertEqual(addresser.get_address_type(rel_address2),
addresser.AddressSpace.ROLES_TASKS)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
user_id1 = addresser.user.unique_id()
user_id2 = addresser.user.unique_id()
rel_address1 = addresser.sysadmin.admin.address(object_id=user_id1)
rel_address2 = addresser.sysadmin.admin.address(object_id=user_id2)
self.assertIsAddress(rel_address1)
self.assertIsAddress(rel_address2)
self.assertNotEqual(rel_address1, rel_address2)
self.assertEqual(
addresser.get_address_type(rel_address1),
addresser.AddressSpace.SYSADMIN_ADMINS,
)
self.assertEqual(
addresser.get_address_type(rel_address2),
addresser.AddressSpace.SYSADMIN_ADMINS,
)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
sysadmin_address = addresser.sysadmin.address()
self.assertIsAddress(sysadmin_address)
self.assertEqual(
addresser.get_address_type(sysadmin_address),
addresser.AddressSpace.SYSADMIN_ATTRIBUTES,
)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
role_id1 = addresser.role.unique_id()
role_id2 = addresser.role.unique_id()
role_address1 = addresser.role.address(object_id=role_id1)
role_address2 = addresser.role.address(object_id=role_id2)
self.assertIsAddress(role_address1)
self.assertIsAddress(role_address2)
self.assertNotEqual(role_address1, role_address2)
self.assertEqual(
addresser.get_address_type(role_address1),
addresser.AddressSpace.ROLES_ATTRIBUTES,
)
self.assertEqual(
addresser.get_address_type(role_address2),
addresser.AddressSpace.ROLES_ATTRIBUTES,
)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
role_id = addresser.role.unique_id()
role_address = addresser.role.address(object_id=role_id)
self.assertIsAddress(role_address)
self.assertEqual(
addresser.get_address_type(role_address),
addresser.AddressSpace.ROLES_ATTRIBUTES,
)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
task_id = addresser.task.admin.unique_id()
next_id = addresser.user.unique_id()
rel_address = addresser.task.admin.address(object_id=task_id,
related_id=next_id)
self.assertIsAddress(rel_address)
self.assertEqual(addresser.get_address_type(rel_address),
addresser.AddressSpace.TASKS_ADMINS)
def _remove(conn, address):
""" Handle the removal of a given address
"""
data_type = addresser.get_address_type(address)
_remove_state(conn, address)
if data_type in TABLE_NAMES:
_remove_legacy(conn, address, data_type)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
role_id = addresser.role.admin.unique_id()
user_id = addresser.user.unique_id()
rel_address = addresser.role.admin.address(object_id=role_id,
related_id=user_id)
self.assertIsAddress(rel_address)
self.assertEqual(addresser.get_address_type(rel_address),
addresser.AddressSpace.ROLES_ADMINS)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
role_id = addresser.role.task.unique_id()
task_id = addresser.task.unique_id()
rel_address = addresser.role.task.address(object_id=role_id,
related_id=task_id)
self.assertIsAddress(rel_address)
self.assertEqual(addresser.get_address_type(rel_address),
addresser.AddressSpace.ROLES_TASKS)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
task_id = addresser.task.unique_id()
task_address = addresser.task.address(object_id=task_id)
self.assertIsAddress(task_address)
self.assertEqual(
addresser.get_address_type(task_address),
addresser.AddressSpace.TASKS_ATTRIBUTES,
)
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
user_id = addresser.user.unique_id()
rel_address = addresser.sysadmin.admin.address(object_id=user_id)
self.assertIsAddress(rel_address)
self.assertEqual(
addresser.get_address_type(rel_address),
addresser.AddressSpace.SYSADMIN_ADMINS,
)
def test_address_deterministic(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
user_id1 = addresser.user.unique_id()
user_address1 = addresser.user.address(user_id1)
user_address2 = addresser.user.address(user_id1)
self.assertIsAddress(user_address1)
self.assertIsAddress(user_address2)
self.assertEqual(user_address1, user_address2)
self.assertEqual(addresser.get_address_type(user_address1),
addresser.AddressSpace.USER)
def _update(conn, block_num, address, resource):
""" Handle the update of a given address + resource update
"""
data_type = addresser.get_address_type(address)
pre_filter(resource)
_update_state(conn, block_num, address, resource)
if data_type in TABLE_NAMES:
_update_legacy(conn, block_num, address, resource, data_type)
def assertValidInputs(self, inputs, outputs, message_type):
"""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.get_address_type(inputs[0]),
addresser.AddressSpace.USER)
self.assertEqual(addresser.get_address_type(outputs[0]),
addresser.AddressSpace.USER)
else:
raise Exception(
"BatchAssertions.assertValidInputs doesn't support message_type {}"
.format(message_type))
def test_address(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
object_id = addresser.proposal.unique_id()
related_id = addresser.proposal.unique_id()
proposal_address = addresser.proposal.address(object_id=object_id,
related_id=related_id)
self.assertIsAddress(proposal_address)
self.assertEqual(
addresser.get_address_type(proposal_address),
addresser.AddressSpace.PROPOSALS,
)
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 = addresser.get_address_type(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_address_deterministic(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
role_id1 = addresser.role.unique_id()
role_address1 = addresser.role.address(object_id=role_id1)
role_address2 = addresser.role.address(object_id=role_id1)
self.assertIsAddress(role_address1)
self.assertIsAddress(role_address2)
self.assertEqual(role_address1, role_address2)
self.assertEqual(
addresser.get_address_type(role_address1),
addresser.AddressSpace.ROLES_ATTRIBUTES,
)
def test_address_deterministic(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
next_id = addresser.user.unique_id()
rel_address1 = addresser.sysadmin.member.address(object_id=next_id)
rel_address2 = addresser.sysadmin.member.address(object_id=next_id)
self.assertIsAddress(rel_address1)
self.assertIsAddress(rel_address2)
self.assertEqual(rel_address1, rel_address2)
self.assertEqual(
addresser.get_address_type(rel_address1),
addresser.AddressSpace.SYSADMIN_MEMBERS,
)
def test_address_deterministic(self):
"""Tests address makes an address that identifies as the correct AddressSpace"""
task_id1 = addresser.task.unique_id()
task_address1 = addresser.task.address(object_id=task_id1)
task_address2 = addresser.task.address(object_id=task_id1)
self.assertIsAddress(task_address1)
self.assertIsAddress(task_address2)
self.assertEqual(task_address1, task_address2)
self.assertEqual(
addresser.get_address_type(task_address1),
addresser.AddressSpace.TASKS_ATTRIBUTES,
)
def test_address_random(self):
"""Tests address makes a unique address given different inputs"""
object_id1 = addresser.proposal.unique_id()
related_id1 = addresser.proposal.unique_id()
object_id2 = addresser.proposal.unique_id()
related_id2 = addresser.proposal.unique_id()
proposal_address1 = addresser.proposal.address(object_id=object_id1,
related_id=related_id1)
proposal_address2 = addresser.proposal.address(object_id=object_id2,
related_id=related_id2)
self.assertIsAddress(proposal_address1)
self.assertIsAddress(proposal_address2)
self.assertNotEqual(proposal_address1, proposal_address2)
self.assertEqual(
addresser.get_address_type(proposal_address1),
addresser.AddressSpace.PROPOSALS,
)
self.assertEqual(
addresser.get_address_type(proposal_address2),
addresser.AddressSpace.PROPOSALS,
)
