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

   1 import unittest
   2
   3 from test_base import TestBase
   4 from opnfv_testapi.resources.testcase_models import TestcaseCreateRequest, \
   5     Testcase, Testcases, TestcaseUpdateRequest
   6 from opnfv_testapi.resources.project_models import ProjectCreateRequest
   7 from opnfv_testapi.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('vping_1',
  18                                            '/cases/vping_1',
  19                                            'vping-ssh test')
  20         self.req_e = TestcaseCreateRequest('doctor_1',
  21                                            '/cases/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_emptyName(self):
  85         req_empty = TestcaseCreateRequest('')
  86         (code, body) = self.create(req_empty, self.project)
  87         self.assertEqual(code, HTTP_BAD_REQUEST)
  88         self.assertIn('name missing', body)
  89
  90     def test_noneName(self):
  91         req_none = TestcaseCreateRequest(None)
  92         (code, body) = self.create(req_none, self.project)
  93         self.assertEqual(code, HTTP_BAD_REQUEST)
  94         self.assertIn('name missing', body)
  95
  96     def test_success(self):
  97         code, body = self.create_d()
  98         self.assertEqual(code, HTTP_OK)
  99         self.assert_create_body(body, None, self.project)
 100
 101     def test_alreadyExist(self):
 102         self.create_d()
 103         code, body = self.create_d()
 104         self.assertEqual(code, HTTP_FORBIDDEN)
 105         self.assertIn('already exists', body)
 106
 107
 108 class TestCaseGet(TestCaseBase):
 109     def test_notExist(self):
 110         code, body = self.get('notExist')
 111         self.assertEqual(code, HTTP_NOT_FOUND)
 112
 113     def test_getOne(self):
 114         self.create_d()
 115         code, body = self.get(self.req_d.name)
 116         self.assertEqual(code, HTTP_OK)
 117         self.assert_body(body)
 118
 119     def test_list(self):
 120         self.create_d()
 121         self.create_e()
 122         code, body = self.get()
 123         for case in body.testcases:
 124             if self.req_d.name == case.name:
 125                 self.assert_body(case)
 126             else:
 127                 self.assert_body(case, self.req_e)
 128
 129
 130 class TestCaseUpdate(TestCaseBase):
 131     def test_noBody(self):
 132         code, _ = self.update(case='noBody')
 133         self.assertEqual(code, HTTP_BAD_REQUEST)
 134
 135     def test_notFound(self):
 136         code, _ = self.update(self.update_e, 'notFound')
 137         self.assertEqual(code, HTTP_NOT_FOUND)
 138
 139     def test_newNameExist(self):
 140         self.create_d()
 141         self.create_e()
 142         code, body = self.update(self.update_e, self.req_d.name)
 143         self.assertEqual(code, HTTP_FORBIDDEN)
 144         self.assertIn("already exists", body)
 145
 146     def test_noUpdate(self):
 147         self.create_d()
 148         code, body = self.update(self.update_d, self.req_d.name)
 149         self.assertEqual(code, HTTP_FORBIDDEN)
 150         self.assertIn("Nothing to update", body)
 151
 152     def test_success(self):
 153         self.create_d()
 154         code, body = self.get(self.req_d.name)
 155         _id = body._id
 156
 157         code, body = self.update(self.update_e, self.req_d.name)
 158         self.assertEqual(code, HTTP_OK)
 159         self.assertEqual(_id, body._id)
 160         self.assert_update_body(self.req_d, body, self.update_e)
 161
 162         _, new_body = self.get(self.req_e.name)
 163         self.assertEqual(_id, new_body._id)
 164         self.assert_update_body(self.req_d, new_body, self.update_e)
 165
 166
 167 class TestCaseDelete(TestCaseBase):
 168     def test_notFound(self):
 169         code, body = self.delete('notFound')
 170         self.assertEqual(code, HTTP_NOT_FOUND)
 171
 172     def test_success(self):
 173         self.create_d()
 174         code, body = self.delete(self.req_d.name)
 175         self.assertEqual(code, HTTP_OK)
 176         self.assertEqual(body, '')
 177
 178         code, body = self.get(self.req_d.name)
 179         self.assertEqual(code, HTTP_NOT_FOUND)
 180
 181
 182 if __name__ == '__main__':
 183     unittest.main()