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_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_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_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_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_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_det_sysadmin_owner_addr(self):
"""Tests that a specific owner_id generates the expected
sysadmin owner address, and thus is probably deterministic.
"""
owner_id = "966ab67317234df489adb4bc1f517b88"
expected_address = "9f4448000000000000000000000000\
00000000000000000000000000000000000000de"
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(address, expected_address,
"The address is the one we expected it to be")
self.assertEqual(
addresser.address_is(address),
AddressSpace.SYSADMIN_OWNERS,
"The address created must be a SysAdmin 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_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_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_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_task_address(self):
"""Tests the task address creation function as well as the
address_is function.
"""
ident = uuid4().hex
address = addresser.make_task_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.TASKS_ATTRIBUTES,
"The address created must be a Task 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.",
)
