From ddc8c833684ff0db65553b09b87eed7b80c7075d Mon Sep 17 00:00:00 2001 From: Dolph Mathews Date: Fri, 9 Nov 2012 08:32:18 -0600 Subject: v3 Identity - v3 identity tests (bug 1023930) - v3 identity implementation (bug 1023937) Change-Id: Ic46575afe9760d9da85e262d0cf063ea002d9dcd --- tests/test_v3_identity.py | 349 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 tests/test_v3_identity.py (limited to 'tests') diff --git a/tests/test_v3_identity.py b/tests/test_v3_identity.py new file mode 100644 index 00000000..43bbf293 --- /dev/null +++ b/tests/test_v3_identity.py @@ -0,0 +1,349 @@ +import uuid + +import test_v3 + + +class IdentityTestCase(test_v3.RestfulTestCase): + """Test domains, projects, users, credential & role CRUD""" + + def setUp(self): + super(IdentityTestCase, self).setUp() + + self.domain_id = uuid.uuid4().hex + self.domain = self.new_domain_ref() + self.domain['id'] = self.domain_id + self.identity_api.create_domain( + self.domain_id, + self.domain.copy()) + + self.project_id = uuid.uuid4().hex + self.project = self.new_project_ref( + domain_id=self.domain_id) + self.project['id'] = self.project_id + self.identity_api.create_project( + self.project_id, + self.project.copy()) + + self.user_id = uuid.uuid4().hex + self.user = self.new_user_ref( + domain_id=self.domain_id, + project_id=self.project_id) + self.user['id'] = self.user_id + self.identity_api.create_user( + self.user_id, + self.user.copy()) + + self.credential_id = uuid.uuid4().hex + self.credential = self.new_credential_ref( + user_id=self.user_id, + project_id=self.project_id) + self.credential['id'] = self.credential_id + self.identity_api.create_credential( + self.credential_id, + self.credential.copy()) + + self.role_id = uuid.uuid4().hex + self.role = self.new_role_ref() + self.role['id'] = self.role_id + self.identity_api.create_role( + self.role_id, + self.role.copy()) + + # domain validation + + def assertValidDomainListResponse(self, resp, ref): + return self.assertValidListResponse( + resp, + 'domains', + self.assertValidDomain, + ref) + + def assertValidDomainResponse(self, resp, ref): + return self.assertValidResponse( + resp, + 'domain', + self.assertValidDomain, + ref) + + def assertValidDomain(self, entity, ref=None): + if ref: + pass + return entity + + # project validation + + def assertValidProjectListResponse(self, resp, ref): + return self.assertValidListResponse( + resp, + 'projects', + self.assertValidProject, + ref) + + def assertValidProjectResponse(self, resp, ref): + return self.assertValidResponse( + resp, + 'project', + self.assertValidProject, + ref) + + def assertValidProject(self, entity, ref=None): + self.assertIsNotNone(entity.get('domain_id')) + if ref: + self.assertEqual(ref['domain_id'], entity['domain_id']) + return entity + + # user validation + + def assertValidUserListResponse(self, resp, ref): + return self.assertValidListResponse( + resp, + 'users', + self.assertValidUser, + ref) + + def assertValidUserResponse(self, resp, ref): + return self.assertValidResponse( + resp, + 'user', + self.assertValidUser, + ref) + + def assertValidUser(self, entity, ref=None): + self.assertIsNotNone(entity.get('domain_id')) + self.assertIsNotNone(entity.get('email')) + self.assertIsNone(entity.get('password')) + if ref: + self.assertEqual(ref['domain_id'], entity['domain_id']) + self.assertEqual(ref['email'], entity['email']) + return entity + + # credential validation + + def assertValidCredentialListResponse(self, resp, ref): + return self.assertValidListResponse( + resp, + 'credentials', + self.assertValidCredential, + ref) + + def assertValidCredentialResponse(self, resp, ref): + return self.assertValidResponse( + resp, + 'credential', + self.assertValidCredential, + ref) + + def assertValidCredential(self, entity, ref=None): + self.assertIsNotNone(entity.get('user_id')) + self.assertIsNotNone(entity.get('blob')) + self.assertIsNotNone(entity.get('type')) + if ref: + self.assertEqual(ref['user_id'], entity['user_id']) + self.assertEqual(ref['blob'], entity['blob']) + self.assertEqual(ref['type'], entity['type']) + self.assertEqual(ref.get('project_id'), entity.get('project_id')) + return entity + + # role validation + + def assertValidRoleListResponse(self, resp, ref): + return self.assertValidListResponse( + resp, + 'roles', + self.assertValidRole, + ref) + + def assertValidRoleResponse(self, resp, ref): + return self.assertValidResponse( + resp, + 'role', + self.assertValidRole, + ref) + + def assertValidRole(self, entity, ref=None): + if ref: + pass + return entity + + # domain crud tests + + def test_create_domain(self): + """POST /domains""" + ref = self.new_domain_ref() + r = self.post( + '/domains', + body={'domain': ref}) + return self.assertValidDomainResponse(r, ref) + + def test_list_domains(self): + """GET /domains""" + r = self.get('/domains') + self.assertValidDomainListResponse(r, self.domain) + + def test_get_domain(self): + """GET /domains/{domain_id}""" + r = self.get('/domains/%(domain_id)s' % { + 'domain_id': self.domain_id}) + self.assertValidDomainResponse(r, self.domain) + + def test_update_domain(self): + """PATCH /domains/{domain_id}""" + ref = self.new_domain_ref() + del ref['id'] + r = self.patch('/domains/%(domain_id)s' % { + 'domain_id': self.domain_id}, + body={'domain': ref}) + self.assertValidDomainResponse(r, ref) + + def test_delete_domain(self): + """DELETE /domains/{domain_id}""" + self.delete('/domains/%(domain_id)s' % { + 'domain_id': self.domain_id}) + + # project crud tests + + def test_list_projects(self): + """GET /projects""" + r = self.get('/projects') + self.assertValidProjectListResponse(r, self.project) + + def test_create_project(self): + """POST /projects""" + ref = self.new_project_ref(domain_id=self.domain_id) + r = self.post( + '/projects', + body={'project': ref}) + self.assertValidProjectResponse(r, ref) + + def test_get_project(self): + """GET /projects/{project_id}""" + r = self.get( + '/projects/%(project_id)s' % { + 'project_id': self.project_id}) + self.assertValidProjectResponse(r, self.project) + + def test_update_project(self): + """PATCH /projects/{project_id}""" + ref = self.new_project_ref(domain_id=self.domain_id) + del ref['id'] + r = self.patch( + '/projects/%(project_id)s' % { + 'project_id': self.project_id}, + body={'project': ref}) + self.assertValidProjectResponse(r, ref) + + def test_delete_project(self): + """DELETE /projects/{project_id}""" + self.delete( + '/projects/%(project_id)s' % { + 'project_id': self.project_id}) + + # user crud tests + + def test_create_user(self): + """POST /users""" + ref = self.new_user_ref(domain_id=self.domain_id) + r = self.post( + '/users', + body={'user': ref}) + return self.assertValidUserResponse(r, ref) + + def test_list_users(self): + """GET /users""" + r = self.get('/users') + self.assertValidUserListResponse(r, self.user) + + def test_get_user(self): + """GET /users/{user_id}""" + r = self.get('/users/%(user_id)s' % { + 'user_id': self.user_id}) + self.assertValidUserResponse(r, self.user) + + def test_update_user(self): + """PATCH /users/{user_id}""" + user = self.new_user_ref(domain_id=self.domain_id) + del user['id'] + r = self.patch('/users/%(user_id)s' % { + 'user_id': self.user_id}, + body={'user': user}) + self.assertValidUserResponse(r, user) + + def test_delete_user(self): + """DELETE /users/{user_id}""" + self.delete('/users/%(user_id)s' % { + 'user_id': self.user_id}) + + # credential crud tests + + def test_list_credentials(self): + """GET /credentials""" + r = self.get('/credentials') + self.assertValidCredentialListResponse(r, self.credential) + + def test_create_credential(self): + """POST /credentials""" + ref = self.new_credential_ref(user_id=self.user_id) + r = self.post( + '/credentials', + body={'credential': ref}) + self.assertValidCredentialResponse(r, ref) + + def test_get_credential(self): + """GET /credentials/{credential_id}""" + r = self.get( + '/credentials/%(credential_id)s' % { + 'credential_id': self.credential_id}) + self.assertValidCredentialResponse(r, self.credential) + + def test_update_credential(self): + """PATCH /credentials/{credential_id}""" + ref = self.new_credential_ref( + user_id=self.user_id, + project_id=self.project_id) + del ref['id'] + r = self.patch( + '/credentials/%(credential_id)s' % { + 'credential_id': self.credential_id}, + body={'credential': ref}) + self.assertValidCredentialResponse(r, ref) + + def test_delete_credential(self): + """DELETE /credentials/{credential_id}""" + self.delete( + '/credentials/%(credential_id)s' % { + 'credential_id': self.credential_id}) + + # role crud tests + + def test_create_role(self): + """POST /roles""" + ref = self.new_role_ref() + r = self.post( + '/roles', + body={'role': ref}) + return self.assertValidRoleResponse(r, ref) + + def test_list_roles(self): + """GET /roles""" + r = self.get('/roles') + self.assertValidRoleListResponse(r, self.role) + + def test_get_role(self): + """GET /roles/{role_id}""" + r = self.get('/roles/%(role_id)s' % { + 'role_id': self.role_id}) + self.assertValidRoleResponse(r, self.role) + + def test_update_role(self): + """PATCH /roles/{role_id}""" + ref = self.new_role_ref() + del ref['id'] + r = self.patch('/roles/%(role_id)s' % { + 'role_id': self.role_id}, + body={'role': ref}) + self.assertValidRoleResponse(r, ref) + + def test_delete_role(self): + """DELETE /roles/{role_id}""" + self.delete('/roles/%(role_id)s' % { + 'role_id': self.role_id}) -- cgit