utils/test/result_collection_api/tests/unit/test_testcase.py

   1 import unittest
   2
   3 from test_base import TestBase
   4 from resources.testcase_models import TestcaseCreateRequest, \
   5     Testcase, Testcases, TestcaseUpdateRequest
   6 from resources.project_models import ProjectCreateRequest
   7 from common.constants import HTTP_OK, HTTP_BAD_REQUEST, \
   8     HTTP_FORBIDDEN, HTTP_NOT_FOUND
   9
  10
  11 __author__ = '__serena__'
  12
  13
  14 class TestCaseBase(TestBase):
  15     def setUp(self):
  16         super(TestCaseBase, self).setUp()
  17         self.req_d = TestcaseCreateRequest('/cases/vping_1',
  18                                            'vping_1',
  19                                            'vping-ssh test')
  20         self.req_e = TestcaseCreateRequest('/cases/doctor_1',
  21                                            'doctor_1',
  22                                            'create doctor')
  23         self.update_d = TestcaseUpdateRequest('vping_1',
  24                                               'vping-ssh test',
  25                                               'functest')
  26         self.update_e = TestcaseUpdateRequest('doctor_1',
  27                                               'create doctor',
  28                                               'functest')
  29         self.get_res = Testcase
  30         self.list_res = Testcases
  31         self.update_res = Testcase
  32         self.basePath = '/api/v1/projects/%s/cases'
  33         self.create_project()
  34
  35     def assert_body(self, case, req=None):
  36         if not req:
  37             req = self.req_d
  38         self.assertEqual(case.name, req.name)
  39         self.assertEqual(case.description, req.description)
  40         self.assertEqual(case.url, req.url)
  41         self.assertIsNotNone(case._id)
  42         self.assertIsNotNone(case.creation_date)
  43
  44     def assert_update_body(self, old, new, req=None):
  45         if not req:
  46             req = self.req_d
  47         self.assertEqual(new.name, req.name)
  48         self.assertEqual(new.description, req.description)
  49         self.assertEqual(new.url, old.url)
  50         self.assertIsNotNone(new._id)
  51         self.assertIsNotNone(new.creation_date)
  52
  53     def create_project(self):
  54         req_p = ProjectCreateRequest('functest', 'vping-ssh test')
  55         self.create_help('/api/v1/projects', req_p)
  56         self.project = req_p.name
  57
  58     def create_d(self):
  59         return super(TestCaseBase, self).create_d(self.project)
  60
  61     def create_e(self):
  62         return super(TestCaseBase, self).create_e(self.project)
  63
  64     def get(self, case=None):
  65         return super(TestCaseBase, self).get(self.project, case)
  66
  67     def update(self, new=None, case=None):
  68         return super(TestCaseBase, self).update(new, self.project, case)
  69
  70     def delete(self, case):
  71         return super(TestCaseBase, self).delete(self.project, case)
  72
  73
  74 class TestCaseCreate(TestCaseBase):
  75     def test_noBody(self):
  76         (code, body) = self.create(None, 'vping')
  77         self.assertEqual(code, HTTP_BAD_REQUEST)
  78
  79     def test_noProject(self):
  80         code, body = self.create(self.req_d, 'noProject')
  81         self.assertEqual(code, HTTP_FORBIDDEN)
  82         self.assertIn('Could not find project', body)
  83
  84     def test_success(self):
  85         code, body = self.create_d()
  86         self.assertEqual(code, HTTP_OK)
  87         self.assert_create_body(body, None, self.project)
  88
  89     def test_alreadyExist(self):
  90         self.create_d()
  91         code, body = self.create_d()
  92         self.assertEqual(code, HTTP_FORBIDDEN)
  93         self.assertIn('already exists', body)
  94
  95
  96 class TestCaseGet(TestCaseBase):
  97     def test_notExist(self):
  98         code, body = self.get('notExist')
  99         self.assertEqual(code, HTTP_NOT_FOUND)
 100
 101     def test_getOne(self):
 102         self.create_d()
 103         code, body = self.get(self.req_d.name)
 104         self.assertEqual(code, HTTP_OK)
 105         self.assert_body(body)
 106
 107     def test_list(self):
 108         self.create_d()
 109         self.create_e()
 110         code, body = self.get()
 111         for case in body.testcases:
 112             if self.req_d.name == case.name:
 113                 self.assert_body(case)
 114             else:
 115                 self.assert_body(case, self.req_e)
 116
 117
 118 class TestCaseUpdate(TestCaseBase):
 119     def test_noBody(self):
 120         code, _ = self.update(case='noBody')
 121         self.assertEqual(code, HTTP_BAD_REQUEST)
 122
 123     def test_notFound(self):
 124         code, _ = self.update(self.update_e, 'notFound')
 125         self.assertEqual(code, HTTP_NOT_FOUND)
 126
 127     def test_newNameExist(self):
 128         self.create_d()
 129         self.create_e()
 130         code, body = self.update(self.update_e, self.req_d.name)
 131         self.assertEqual(code, HTTP_FORBIDDEN)
 132         self.assertIn("already exists", body)
 133
 134     def test_noUpdate(self):
 135         self.create_d()
 136         code, body = self.update(self.update_d, self.req_d.name)
 137         self.assertEqual(code, HTTP_FORBIDDEN)
 138         self.assertIn("Nothing to update", body)
 139
 140     def test_success(self):
 141         self.create_d()
 142         code, body = self.get(self.req_d.name)
 143         _id = body._id
 144
 145         code, body = self.update(self.update_e, self.req_d.name)
 146         self.assertEqual(code, HTTP_OK)
 147         self.assertEqual(_id, body._id)
 148         self.assert_update_body(self.req_d, body, self.update_e)
 149
 150         _, new_body = self.get(self.req_e.name)
 151         self.assertEqual(_id, new_body._id)
 152         self.assert_update_body(self.req_d, new_body, self.update_e)
 153
 154
 155 class TestCaseDelete(TestCaseBase):
 156     def test_notFound(self):
 157         code, body = self.delete('notFound')
 158         self.assertEqual(code, HTTP_NOT_FOUND)
 159
 160     def test_success(self):
 161         self.create_d()
 162         code, body = self.delete(self.req_d.name)
 163         self.assertEqual(code, HTTP_OK)
 164         self.assertEqual(body, '')
 165
 166         code, body = self.get(self.req_d.name)
 167         self.assertEqual(code, HTTP_NOT_FOUND)
 168
 169
 170 if __name__ == '__main__':
 171     unittest.main()