def test_update_credential(self):
user = fixtures.User(self.client, self.test_domain.id)
self.useFixture(user)
new_user = fixtures.User(self.client, self.test_domain.id)
self.useFixture(new_user)
new_project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(new_project)
credential = fixtures.Credential(self.client,
user=user.id,
type='cert')
self.useFixture(credential)
new_type = 'ec2'
new_blob = ("{\"access\":\"" + uuid.uuid4().hex +
"\",\"secret\":\"secretKey\"}")
credential_ret = self.client.credentials.update(credential.id,
user=new_user.id,
type=new_type,
blob=new_blob,
project=new_project.id)
credential.ref.update({
'user': new_user.id,
'type': new_type,
'blob': new_blob,
'project': new_project.id
})
self.check_credential(credential_ret, credential.ref)
def test_list_credentials(self):
user = fixtures.User(self.client, self.test_domain.id)
self.useFixture(user)
cert_credential = fixtures.Credential(self.client,
user=user.id,
type='cert')
self.useFixture(cert_credential)
project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project)
ec2_credential = fixtures.Credential(self.client,
user=user.id,
type='ec2',
project=project.id)
self.useFixture(ec2_credential)
totp_credential = fixtures.Credential(self.client,
user=user.id,
type='totp')
self.useFixture(totp_credential)
credentials = self.client.credentials.list()
# All credentials are valid
for credential in credentials:
self.check_credential(credential)
self.assertIn(cert_credential.entity, credentials)
self.assertIn(ec2_credential.entity, credentials)
self.assertIn(totp_credential.entity, credentials)
def setUp(self):
super(ProjectsTestCase, self).setUp()
self.test_domain = fixtures.Domain(self.client)
self.useFixture(self.test_domain)
self.test_project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(self.test_project)
def test_get_hierarchy_as_ids(self):
project = fixtures.Project(self.client,
self.test_domain.id,
parent=self.test_project.id)
self.useFixture(project)
child_project = fixtures.Project(self.client,
self.test_domain.id,
parent=project.id)
self.useFixture(child_project)
project_ret = self.client.projects.get(project.id,
subtree_as_ids=True,
parents_as_ids=True)
self.assertItemsEqual([self.test_project.id], project_ret.parents)
self.assertItemsEqual([child_project.id], project_ret.subtree)
def test_add_invalid_tags(self):
project_one = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project_one)
self.assertRaises(exceptions.BadRequest, project_one.add_tag, ',')
self.assertRaises(exceptions.BadRequest, project_one.add_tag, '/')
self.assertRaises(exceptions.BadRequest, project_one.add_tag, '')
def setUp(self):
super(ProjectsTestCase, self).setUp()
self.test_domain = fixtures.Domain(self.client)
self.useFixture(self.test_domain)
self.test_project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(self.test_project)
self.special_tag = '~`!@#$%^&*()-_+=<>.? \'"'
def test_add_endpoint_group_to_project(self):
project = fixtures.Project(self.client)
endpoint_group = fixtures.EndpointGroup(self.client)
self.useFixture(project)
self.useFixture(endpoint_group)
self.client.endpoint_filter.add_endpoint_group_to_project(
endpoint_group, project)
self.client.endpoint_filter.check_endpoint_group_in_project(
endpoint_group, project)
def setUp(self):
super(EndpointFiltersTestCase, self).setUp()
self.project = fixtures.Project(self.client)
self.endpoint_group = fixtures.EndpointGroup(self.client)
self.useFixture(self.project)
self.useFixture(self.endpoint_group)
self.client.endpoint_filter.add_endpoint_group_to_project(
self.endpoint_group, self.project)
def test_update_project_domain_not_allowed(self):
project = fixtures.Project(self.client)
self.useFixture(project)
domain = fixtures.Domain(self.client)
self.useFixture(domain)
# Cannot update domain after project is created.
self.assertRaises(http.BadRequest,
self.client.projects.update,
project.id,
domain=domain.id)
def test_delete_ec2(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
ec2 = self.client.ec2.create(user.id, project.id)
self.client.ec2.delete(user.id, ec2.access)
self.assertRaises(http.NotFound, self.client.ec2.get, user.id,
ec2.access)
def test_create_ec2(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
ec2_ref = {'user_id': user.id, 'project_id': project.id}
ec2 = self.client.ec2.create(**ec2_ref)
self.addCleanup(self.client.ec2.delete, user.id, ec2.access)
self.check_ec2(ec2, ec2_ref)
def test_get_ec2(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
ec2 = fixtures.EC2(self.client, user_id=user.id, project_id=project.id)
self.useFixture(ec2)
ec2_ret = self.client.ec2.get(user.id, ec2.access)
self.check_ec2(ec2_ret, ec2.ref)
def test_check_tag(self):
project = fixtures.Project(self.client,
self.test_domain.id,
tags=['tag1'])
self.useFixture(project)
tags = self.client.projects.get(project.id).tags
self.assertEqual(['tag1'], tags)
self.assertTrue(project.check_tag('tag1'))
self.assertFalse(project.check_tag('tag2'))
self.assertFalse(project.check_tag(self.special_tag))
def test_add_tag(self):
project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project)
tags = self.client.projects.get(project.id).tags
self.assertEqual([], tags)
project.add_tag('tag1')
tags = self.client.projects.get(project.id).tags
self.assertEqual(['tag1'], tags)
# verify there is an error when you try to add the same tag
self.assertRaises(http.BadRequest, project.add_tag, 'tag1')
def test_delete_tag(self):
project = fixtures.Project(self.client,
self.test_domain.id,
tags=['tag1', self.special_tag])
self.useFixture(project)
project.delete_tag('tag1')
tags = self.client.projects.get(project.id).tags
self.assertEqual([self.special_tag], tags)
project.delete_tag(self.special_tag)
tags = self.client.projects.get(project.id).tags
self.assertEqual([], tags)
def test_get_hierarchy_as_list(self):
parent_project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(parent_project)
project = fixtures.Project(self.client,
self.project_domain_id,
parent=parent_project.id)
self.useFixture(project)
child_project = fixtures.Project(self.client,
self.project_domain_id,
parent=project.id)
self.useFixture(child_project)
# Only parents and subprojects that the current user has role
# assingments on are returned when asked for subtree_as_list and
# parents_as_list.
role = fixtures.Role(self.client)
self.useFixture(role)
self.client.roles.grant(role.id,
user=self.user_id,
project=parent_project.id)
self.client.roles.grant(role.id, user=self.user_id, project=project.id)
self.client.roles.grant(role.id,
user=self.user_id,
project=child_project.id)
project_ret = self.client.projects.get(project.id,
subtree_as_list=True,
parents_as_list=True)
self.check_project(project_ret, project.ref)
self.assertItemsEqual([{
'project': parent_project.entity.to_dict()
}], project_ret.parents)
self.assertItemsEqual([{
'project': child_project.entity.to_dict()
}], project_ret.subtree)
def test_list_subprojects(self):
parent_project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(parent_project)
child_project_one = fixtures.Project(self.client, self.test_domain.id,
parent=parent_project.id)
self.useFixture(child_project_one)
child_project_two = fixtures.Project(self.client, self.test_domain.id,
parent=parent_project.id)
self.useFixture(child_project_two)
projects = self.client.projects.list(parent=parent_project.id)
# All projects are valid
for project in projects:
self.check_project(project)
self.assertIn(child_project_one.entity, projects)
self.assertIn(child_project_two.entity, projects)
# Parent project should not be included in the result
self.assertNotIn(parent_project.entity, projects)
def test_update_invalid_tags(self):
tags_comma = ['tag1', ',']
tags_slash = ['tag1', '/']
tags_blank = ['tag1', '']
project_one = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project_one)
self.assertRaises(exceptions.BadRequest, project_one.update_tags,
tags_comma)
self.assertRaises(exceptions.BadRequest, project_one.update_tags,
tags_slash)
self.assertRaises(exceptions.BadRequest, project_one.update_tags,
tags_blank)
def test_list_projects_for_endpoint_group(self):
project_two = fixtures.Project(self.client)
self.useFixture(project_two)
self.client.endpoint_filter.add_endpoint_group_to_project(
self.endpoint_group, project_two)
f = self.client.endpoint_filter.list_projects_for_endpoint_group
projects = f(self.endpoint_group)
for project in projects:
self.check_project(project)
self.assertIn(self.project.entity, projects)
self.assertIn(project_two.entity, projects)
def test_update_project(self):
project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project)
new_name = fixtures.RESOURCE_NAME_PREFIX + uuid.uuid4().hex
new_description = uuid.uuid4().hex
project_ret = self.client.projects.update(project.id,
name=new_name,
enabled=False,
description=new_description)
project.ref.update({'name': new_name, 'enabled': False,
'description': new_description})
self.check_project(project_ret, project.ref)
def test_get_credential(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
for credential_type in ['cert', 'ec2', 'totp']:
credential = fixtures.Credential(self.client,
user=user.id,
type=credential_type,
project=project.id)
self.useFixture(credential)
credential_ret = self.client.credentials.get(credential.id)
self.check_credential(credential_ret, credential.ref)
def test_group_project_grant_and_revoke(self):
group = fixtures.Group(self.client, self.project_domain_id)
self.useFixture(group)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
role = fixtures.Role(self.client, domain=self.project_domain_id)
self.useFixture(role)
self.client.roles.grant(role, group=group.id, project=project.id)
roles_after_grant = self.client.roles.list(group=group.id,
project=project.id)
self.assertItemsEqual(roles_after_grant, [role.entity])
self.client.roles.revoke(role, group=group.id, project=project.id)
roles_after_revoke = self.client.roles.list(group=group.id,
project=project.id)
self.assertEqual(roles_after_revoke, [])
def test_user_project_grant_and_revoke(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
role = fixtures.Role(self.client, domain=self.project_domain_id)
self.useFixture(role)
self.client.roles.grant(role, user=user.id, project=project.id)
roles_after_grant = self.client.roles.list(user=user.id,
project=project.id)
self.assertItemsEqual(roles_after_grant, [role.entity])
self.client.roles.revoke(role, user=user.id, project=project.id)
roles_after_revoke = self.client.roles.list(user=user.id,
project=project.id)
self.assertEqual(roles_after_revoke, [])
def test_update_tags(self):
project = fixtures.Project(self.client, self.test_domain.id)
self.useFixture(project)
tags = self.client.projects.get(project.id).tags
self.assertEqual([], tags)
project.update_tags(['tag1', 'tag2', self.special_tag])
tags = self.client.projects.get(project.id).tags
self.assertIn('tag1', tags)
self.assertIn('tag2', tags)
self.assertIn(self.special_tag, tags)
self.assertEqual(3, len(tags))
project.update_tags([])
tags = self.client.projects.get(project.id).tags
self.assertEqual([], tags)
# cannot have duplicate tags in update
self.assertRaises(http.BadRequest, project.update_tags,
['tag1', 'tag1'])
def test_delete_credential(self):
user = fixtures.User(self.client, self.project_domain_id)
self.useFixture(user)
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
for credential_type in ['cert', 'ec2', 'totp']:
if credential_type == 'ec2':
blob_value = ("{\"access\":\"" + uuid.uuid4().hex +
"\",\"secret\":\"secretKey\"}")
else:
blob_value = uuid.uuid4().hex
credential = self.client.credentials.create(user=user.id,
type=credential_type,
blob=blob_value,
project=project.id)
self.client.credentials.delete(credential.id)
self.assertRaises(http.NotFound, self.client.credentials.get,
credential.id)
def test_get_project(self):
project = fixtures.Project(self.client, self.project_domain_id)
self.useFixture(project)
project_ret = self.client.projects.get(project.id)
self.check_project(project_ret, project.ref)
