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_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_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_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 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_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 _handle_delta(database, delta):
# Check for and resolve forks
old_block = database.fetch('blocks', delta.block_num)
if old_block is not None:
if old_block['block_id'] != delta.block_id:
drop_results = database.drop_fork(delta.block_num)
if drop_results['deleted'] == 0:
LOGGER.warning(
'Failed to drop forked resources since block: %s',
delta.block_num)
else:
return
# Parse changes and update database
update = get_updater(database, delta.block_num)
for change in delta.state_changes:
if namespace_ok(change.address):
resources = data_to_dicts(change.address, change.value)
for resource in resources:
update_results = update(change.address, resource)
if update_results['inserted'] == 0:
LOGGER.warning(
'Failed to insert resource from address: %s',
change.address)
# Add new block to database
new_block = {'block_num': delta.block_num, 'block_id': delta.block_id}
block_results = database.insert('blocks', new_block)
if block_results['inserted'] == 0:
LOGGER.warning('Failed to insert block #%s: %s', delta.block_num,
delta.block_id)
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_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_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_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.")
