def get_group(self, group_element, deep_copy):
uri = group_element.get("uri")
if uri is None:
raise GroupParsingException("group missing required uri attribute")
if string.find(uri, GROUP_URI) != 0:
raise GroupParsingException(
"group uri attribute malformed: {0}".format(uri))
group_id = uri[len(GROUP_URI):]
group = Group(group_id)
group.owner = self._get_owner(group_element)
if deep_copy:
group.description = self._get_child_text(group_element,
'description')
last_modified = self._get_child_text(group_element, 'lastModified')
if last_modified is not None:
group.last_modified = str2ivoa(last_modified)
group.properties = self._get_group_properties(group_element)
group.group_members = self._get_groups(group_element,
'groupMembers')
group.user_members = self._get_users(group_element, 'userMembers')
group.group_admins = self._get_groups(group_element, 'groupAdmins')
group.user_admins = self._get_users(group_element, 'userAdmins')
return group
def test_maximal_group(self):
expected = Group('groupID', User(Identity('username', 'HTTP')))
expected.description = 'description'
expected.last_modified = datetime(2014, 01, 20, 19, 45, 37, 0)
expected.properties.add(GroupProperty('key1', 'value1', True))
expected.properties.add(GroupProperty('key2', 'value2', False))
group_member1 = Group('groupMember1', User(Identity('uid1', 'UID')))
group_member2 = Group('groupMember2', User(Identity('uid2', 'UID')))
expected.group_members.add(group_member1)
expected.group_members.add(group_member2)
user_member1 = User(Identity('openid1', 'OpenID'))
user_member2 = User(Identity('openid2', 'OpenID'))
expected.user_members.add(user_member1)
expected.user_members.add(user_member2)
group_admin1 = Group('adminMember1', User(Identity('x5001', 'X500')))
group_admin2 = Group('adminMember2', User(Identity('x5002', 'X500')))
expected.group_admins.add(group_admin1)
expected.group_admins.add(group_admin2)
user_admin1 = User(Identity('foo1', 'HTTP'))
user_admin2 = User(Identity('foo2', 'HTTP'))
expected.user_admins.add(user_admin1)
expected.user_admins.add(user_admin2)
writer = GroupWriter()
xml_string = writer.write(expected, True)
self.assertIsNotNone(xml_string)
self.assertTrue(len(xml_string) > 0)
reader = GroupReader()
actual = reader.read(xml_string)
self.assertIsNotNone(expected.group_id)
self.assertIsNotNone(actual.group_id)
self.assertEqual(actual.group_id, expected.group_id)
self.assertEqual(actual.owner.user_id.type, expected.owner.user_id.type)
self.assertEqual(actual.owner.user_id.name, expected.owner.user_id.name)
self.assertEqual(actual.description, expected.description)
self.assertEqual(actual.last_modified, expected.last_modified)
self.assertSetEqual(actual.properties, expected.properties)
self.assertSetEqual(actual.group_members, expected.group_members)
self.assertSetEqual(actual.user_members, expected.user_members)
self.assertSetEqual(actual.group_admins, expected.group_admins)
self.assertSetEqual(actual.user_admins, expected.user_admins)
def get_group(self, group_element, deep_copy):
uri = group_element.get("uri")
if uri is None:
raise GroupParsingException("group missing required uri attribute")
if string.find(uri, GROUP_URI) != 0:
raise GroupParsingException(
"group uri attribute malformed: " + uri)
group_id = uri[len(GROUP_URI):]
owner = self._get_owner(group_element)
group = Group(group_id, owner)
if deep_copy:
group.description = self._get_child_text(group_element,
'description')
last_modified = self._get_child_text(group_element, 'lastModified')
if last_modified is not None:
group.last_modified = str2ivoa(last_modified)
group.properties = self._get_group_properties(group_element)
group.group_members = self._get_groups(group_element,
'groupMembers')
group.user_members = self._get_users(group_element, 'userMembers')
group.group_admins = self._get_groups(group_element, 'groupAdmins')
group.user_admins = self._get_users(group_element, 'userAdmins')
return group
def test_groups_client(self):
self.init()
# Use the first version for lots of debugging information
# client = GroupsClient(self.cert_file, log_level=logging.DEBUG)
client = GroupsClient(self.cert_file)
# create a group
expected = Group(self.get_group_id("py1"))
expected.description = "group description"
print "expected group {0}".format(expected)
try:
client.create_group(expected)
except Exception, e:
self.fail("Error creating group because {0}".format(repr(e)))
def test_groups_client(self):
self.init()
# Use the first version for lots of debugging information
#client = GroupsClient(self.cert_file, log_level=logging.DEBUG)
client = GroupsClient(self.cert_file)
# create a group
expected = Group(self.get_group_id('py1'))
expected.description = 'group description'
print 'expected group {0}'.format(expected)
try:
client.create_group(expected)
except Exception, e:
self.fail('Error creating group because {0}'.format(repr(e)))
def test_minimal_group(self):
expected = Group('groupID')
writer = GroupWriter()
xml_string = writer.write(expected, False)
self.assertIsNotNone(xml_string)
self.assertTrue(len(xml_string) > 0)
reader = GroupReader()
actual = reader.read(xml_string)
self.assertIsNotNone(expected.group_id)
self.assertIsNotNone(actual.group_id)
self.assertEqual(actual.group_id, expected.group_id)
self.assertIsNone(expected.owner)
self.assertIsNone(actual.owner)
self.assertIsNone(expected.description)
self.assertIsNone(actual.description)
self.assertIsNone(expected.last_modified)
self.assertIsNone(actual.last_modified)
self.assertItemsEqual(actual.group_members, expected.group_members)
self.assertItemsEqual(actual.user_members, expected.user_members)
self.assertItemsEqual(actual.group_admins, expected.group_admins)
self.assertItemsEqual(actual.user_admins, expected.user_admins)
def test_groups_client(self):
self.init()
# Use the first version for lots of debugging information
#client = GroupsClient(self.cert_file, log_level=logging.DEBUG)
client = GroupsClient(self.cert_file)
# create the owner
owner = User(Identity(client.current_user_dn, 'X500'))
# create a group
expected = Group(self.get_group_id('py1'), owner)
expected.description = 'group description'
print 'expected group ' + expected
try:
client.create_group(expected)
except Exception, e:
self.fail('Error creating group because ' + repr(e))
def test_minimal_read_write(self):
group1 = Group('groupID_1')
group2 = Group('groupID_2')
owner1 = User(
'ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000a')
owner2 = User(
'ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000b')
group1.owner = owner1
group2.owner = owner2
expected = [group1, group2]
writer = GroupsWriter()
xml_string = writer.write(expected, False)
self.assertIsNotNone(xml_string)
self.assertTrue(len(xml_string) > 0)
reader = GroupsReader()
actual = reader.read(xml_string)
self.assertIsNotNone(actual)
self.assertTrue(len(actual) == 2)
self.assertTrue(group1 in actual)
self.assertTrue(group2 in actual)
def test_users_client(self):
self.init()
# Since the UsersClient can't currently create a user, as a work around
# we create a new group, get the group, and use the group owner as
# the user to try and get using the user client.
groups_client = GroupsClient(self.cert_file)
group = Group(GroupsClientIntTest.get_group_id('py1'))
try:
groups_client.create_group(group)
except Exception, e:
self.fail('Error creating group because {0}'.format(repr(e)))
def test_minimal_read_write(self):
group1 = Group('groupID_1')
group2 = Group('groupID_2')
owner1 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000a')
owner2 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000b')
group1.owner = owner1
group2.owner = owner2
expected = [group1, group2]
writer = GroupsWriter()
xml_string = writer.write(expected, False)
self.assertIsNotNone(xml_string)
self.assertTrue(len(xml_string) > 0)
reader = GroupsReader()
actual = reader.read(xml_string)
self.assertIsNotNone(actual)
self.assertTrue(len(actual) == 2)
self.assertTrue(group1 in actual)
self.assertTrue(group2 in actual)
# get the group and confirm membership
try:
actual = client.get_group(expected.group_id)
except Exception, e:
self.fail('Error getting group because {0}'.format(repr(e)))
self.assertTrue(len(actual.user_members) == 0)
# delete the user again, should throw MemberNotFoundException
try:
client.remove_user_member(identity, expected.group_id)
except Exception as e:
self.assertTrue(isinstance(e, MemberNotFoundException))
# create a second test group
group_member = Group(self.get_group_id('py2'))
try:
client.create_group(group_member)
except Exception, e:
self.fail('Error creating group because {0}'.format(repr(e)))
print 'group member {0}'.format(group_member)
expected.group_members.add(group_member)
expected.group_admins.add(group_member)
# writer = GroupWriter()
# expected_xml = writer.write(expected)
# print "expected:\n{0}".format(expected_xml)
try:
client.update_group(expected)
def test_maximal_group(self):
owner = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000a')
owner.identities.add(Identity('cn=foo,c=ca', 'X500'))
owner.identities.add(Identity('*****@*****.**', 'OpenID'))
owner.identities.add(Identity('foo', 'HTTP'))
owner.identities.add(Identity('00000000-0000-0000-0000-000000000001', 'CADC'))
expected = Group('groupID')
expected.owner = owner
expected.description = 'description'
expected.last_modified = datetime(2014, 01, 20, 19, 45, 37, 0)
expected.properties.add(GroupProperty('key1', 'value1', True))
expected.properties.add(GroupProperty('key2', 'value2', False))
user1 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000b')
user2 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000c')
group_member1 = Group('groupMember1')
group_member1.owner = user1
group_member2 = Group('groupMember2')
group_member2.owner = user2
expected.group_members.add(group_member1)
expected.group_members.add(group_member2)
user_member1 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000d')
user_member2 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000e')
expected.user_members.add(user_member1)
expected.user_members.add(user_member2)
owner1 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-00000000000f')
owner2 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-0000000000aa')
group_admin1 = Group('adminMember1')
group_admin1.owner = owner1
group_admin2 = Group('adminMember2')
group_admin2.owner = owner2
expected.group_admins.add(group_admin1)
expected.group_admins.add(group_admin2)
user_admin1 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-0000000000ab')
user_admin2 = User('ivo://cadc.nrc.ca/user?00000000-0000-0000-0000-0000000000ac')
expected.user_admins.add(user_admin1)
expected.user_admins.add(user_admin2)
writer = GroupWriter()
xml_string = writer.write(expected, True)
self.assertIsNotNone(xml_string)
self.assertTrue(len(xml_string) > 0)
reader = GroupReader()
actual = reader.read(xml_string)
self.assertIsNotNone(expected.group_id)
self.assertIsNotNone(actual.group_id)
self.assertEqual(actual.group_id, expected.group_id)
self.assertEqual(actual.owner.internal_id, expected.owner.internal_id)
self.assertSetEqual(actual.owner.identities, expected.owner.identities)
self.assertEqual(actual.description, expected.description)
self.assertEqual(actual.last_modified, expected.last_modified)
self.assertSetEqual(actual.properties, expected.properties)
self.assertSetEqual(actual.group_members, expected.group_members)
self.assertSetEqual(actual.user_members, expected.user_members)
self.assertSetEqual(actual.group_admins, expected.group_admins)
self.assertSetEqual(actual.user_admins, expected.user_admins)
test_params = {'IDTYPE': 'x500', 'ROLE': 'member', 'ID': test_x500_dn}
mock_session = mock.Mock(spec=requests.Session())
mock_response = mock.Mock(spec=requests.Response())
# XML test return documents and corresponding group ID sets
_XML0 = '<?xml version="1.0" encoding="UTF-8"?>\r\n<groups />\r\n'
_XML1 = '<?xml version="1.0" encoding="UTF-8"?>\r\n<groups>\r\n' + \
'<group uri="ivo://cadc.nrc.ca/gms?groupA">\r\n</group>' + \
'\r\n</groups>'
_XML2 = '<?xml version="1.0" encoding="UTF-8"?>\r\n<groups>\r\n' + \
'<group uri="ivo://cadc.nrc.ca/gms?groupA">\r\n</group>' + \
'<group uri="ivo://cadc.nrc.ca/gms?groupB">\r\n</group>' + \
'\r\n</groups>'
groups0 = []
groups1 = [Group('groupA')]
groups2 = [Group('groupA'), Group('groupB')]
class GroupsClientForTest(GroupsClient):
"""Subclass of GroupsClient with some hacks"""
def __init__(self, *args, **kwargs):
super(GroupsClientForTest, self).__init__(*args, **kwargs)
self.base_url = test_base_url
self.certificate_file_location = test_certificate_name
self.is_authorized = True
self.current_user_dn = test_x500_dn
@staticmethod
def read_data(location):
f = open(location, 'r')
