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 test_task_addresses(self):
"""Tests the Task address creation functions as well as the
address_is function.
Notes:
1. Create an address of a particular type:
- Task Attributes
- Task Owners
- Task Admins
2. Assert that address_is returns the correct address type.
"""
task_address = addresser.make_task_attributes_address(uuid4().hex)
self.assertEqual(len(task_address), 70,
"The address is a well-formed address.")
self.assertEqual(
addresser.address_is(task_address),
AddressSpace.TASKS_ATTRIBUTES,
"The Task Attributes address created must be "
"found to be a Task Attributes address.")
task_owners_address = addresser.make_task_owners_address(
task_id=uuid4().hex,
user_id=uuid4().hex)
self.assertEqual(len(task_owners_address), 70,
"The address is a well-formed address.")
self.assertEqual(
addresser.address_is(task_owners_address),
AddressSpace.TASKS_OWNERS,
"The Task Owners address created must be "
"found to be a Task Owners address.")
task_admins_address = addresser.make_task_admins_address(
task_id=uuid4().hex,
user_id=uuid4().hex)
self.assertEqual(len(task_admins_address), 70,
"The address is a well-formed address.")
self.assertEqual(
addresser.address_is(task_admins_address),
AddressSpace.TASKS_ADMINS,
"The Task Admins address created must be "
"found to be a Task Admins 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_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_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 test_determine_role_owner_addr(self):
"""Tests that a specific role_id and owner_id generates the
expected role owner address, and thus is probably deterministic.
"""
role_id = '99968acb8f1a48b3a4bc21e2cd252e67'
owner_id = '966ab67317234df489adb4bc1f517b88'
expected_address = '9f444809326a1713a905b26359fc8d\
a2817c1a5f67de6f464701f0c10042da345d2893'
address = addresser.make_role_owners_address(role_id, owner_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_OWNERS,
"The address created must be a Role Attributes address.")
def test_determine_sysadmin_addr(self):
"""Tests that a specific sysadmin_id generates the expected
sysadmin address, and thus is probably deterministic.
"""
expected_address = '9f4448000000000000000000000000\
0000000000000000000000000000000000000000'
address = addresser.make_sysadmin_attr_address()
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.SYSADMIN_ATTRIBUTES,
"The address created must be a SysAdmin Attributes address.")
def test_generated_role_owner_addr(self):
"""Tests the role owner address creation function as well as the
address_is function.
"""
role_id = uuid4().hex
owner_id = uuid4().hex
address = addresser.make_role_owners_address(role_id, owner_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.ROLES_OWNERS,
"The address created must be a Role Attributes 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_gen_sysadmin_owner_addr(self):
"""Tests the sysadmin owner address creation function as well as the
address_is function.
"""
owner_id = uuid4().hex
address = addresser.make_sysadmin_owners_address(owner_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.SYSADMIN_OWNERS,
"The address created must be a SysAdmin Attributes 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_generated_task_admin_addr(self):
"""Tests the task admin address creation function as well as the
address_is function.
"""
task_id = uuid4().hex
admin_id = uuid4().hex
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(
addresser.address_is(address),
AddressSpace.TASKS_ADMINS,
"The address created must be a Task Attributes 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_det_sysadmin_member_addr(self):
"""Tests that a specific member_id generates the expected
sysadmin member address, and thus is probably deterministic.
"""
member_id = '966ab67317234df489adb4bc1f517b88'
expected_address = '9f4448000000000000000000000000\
0000000000000000000000000000000000000083'
address = addresser.make_sysadmin_members_address(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.SYSADMIN_MEMBERS,
"The address created must be a SysAdmin Attributes address.")
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 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 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_wrong_family_address(self):
"""Tests that an address with the wrong family prefix
does not validate.
"""
address = '8f444847e7570f3f6f7d2c1635f6de\
eabc1f4d78d9d42b64b70e1819f244138c1e38d6'
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.assertFalse(addresser.namespace_ok(address),
"The address does not have correct namespace prefix")
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_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 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 _update(database, block_num, address, resource):
data_type = address_is(address)
resource['start_block_num'] = block_num
resource['end_block_num'] = 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'] = 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_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_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.")
