Merge "add pod related unittests in testAPI"
authorMorgan Richomme <morgan.richomme@orange.com>
Wed, 18 May 2016 12:27:46 +0000 (12:27 +0000)
committerGerrit Code Review <gerrit@172.30.200.206>
Wed, 18 May 2016 12:27:46 +0000 (12:27 +0000)
utils/test/result_collection_api/common/constants.py
utils/test/result_collection_api/resources/handlers.py
utils/test/result_collection_api/resources/models.py
utils/test/result_collection_api/resources/pod_models.py [new file with mode: 0644]
utils/test/result_collection_api/tests/unit/fake_pymongo.py
utils/test/result_collection_api/tests/unit/test_base.py
utils/test/result_collection_api/tests/unit/test_pod.py [new file with mode: 0644]

index 2c825c1..4d39a14 100644 (file)
@@ -12,3 +12,4 @@ DEFAULT_REPRESENTATION = "application/json"
 HTTP_BAD_REQUEST = 400
 HTTP_FORBIDDEN = 403
 HTTP_NOT_FOUND = 404
+HTTP_OK = 200
index c1e8eb1..fff1662 100644 (file)
@@ -13,7 +13,8 @@ from tornado.web import RequestHandler, asynchronous, HTTPError
 from tornado import gen
 from datetime import datetime, timedelta
 
-from models import Pod, TestProject, TestCase, TestResult
+from models import TestProject, TestCase, TestResult
+from resources.pod_models import Pod
 from common.constants import DEFAULT_REPRESENTATION, HTTP_BAD_REQUEST, \
     HTTP_NOT_FOUND, HTTP_FORBIDDEN
 from common.config import prepare_put_request
index 06e95f9..adf6842 100644 (file)
@@ -5,47 +5,41 @@
 # are made available under the terms of the Apache License, Version 2.0\r
 # which accompanies this distribution, and is available at\r
 # http://www.apache.org/licenses/LICENSE-2.0\r
+# feng.xiaowei@zte.com.cn  mv Pod to pod_models.py                 6-18-2016\r
+# feng.xiaowei@zte.com.cn  add MetaCreateResponse/MetaGetResponse  6-18-2016\r
 ##############################################################################\r
 \r
 \r
-class Pod:\r
-    """ describes a POD platform """\r
-    def __init__(self):\r
-        self._id = ""\r
-        self.name = ""\r
-        self.creation_date = ""\r
-        self.mode = ""\r
-        self.details = ""\r
+class MetaCreateResponse(object):\r
+    def __init__(self, success=True, uri=''):\r
+        self.success = success\r
+        self.uri = uri\r
 \r
     @staticmethod\r
-    def pod_from_dict(pod_dict):\r
-        if pod_dict is None:\r
+    def from_dict(meta_dict):\r
+        if meta_dict is None:\r
             return None\r
 \r
-        p = Pod()\r
-        p._id = pod_dict.get('_id')\r
-        p.creation_date = str(pod_dict.get('creation_date'))\r
-        p.name = pod_dict.get('name')\r
-        p.mode = pod_dict.get('mode')\r
-        p.details = pod_dict.get('details')\r
-        return p\r
+        meta = MetaCreateResponse()\r
+        meta.success = meta_dict.get('success')\r
+        meta.uri = meta_dict.get('uri')\r
+        return meta\r
 \r
-    def format(self):\r
-        return {\r
-            "name": self.name,\r
-            "mode": self.mode,\r
-            "details": self.details,\r
-            "creation_date": str(self.creation_date),\r
-        }\r
 \r
-    def format_http(self):\r
-        return {\r
-            "_id": str(self._id),\r
-            "name": self.name,\r
-            "mode": self.mode,\r
-            "details": self.details,\r
-            "creation_date": str(self.creation_date),\r
-        }\r
+class MetaGetResponse(object):\r
+    def __init__(self, success=True, total=0):\r
+        self.success = success\r
+        self.total = total\r
+\r
+    @staticmethod\r
+    def from_dict(meta_dict):\r
+        if meta_dict is None:\r
+            return None\r
+\r
+        meta = MetaGetResponse()\r
+        meta.success = meta_dict.get('success')\r
+        meta.total = meta_dict.get('total')\r
+        return meta\r
 \r
 \r
 class TestProject:\r
diff --git a/utils/test/result_collection_api/resources/pod_models.py b/utils/test/result_collection_api/resources/pod_models.py
new file mode 100644 (file)
index 0000000..5c4ef72
--- /dev/null
@@ -0,0 +1,108 @@
+from models import MetaCreateResponse, MetaGetResponse
+
+
+class PodCreateRequest(object):
+    def __init__(self, name='', mode='', details=''):
+        self.name = name
+        self.mode = mode
+        self.details = details
+
+    def format(self):
+        return {
+            "name": self.name,
+            "mode": self.mode,
+            "details": self.details,
+        }
+
+    @staticmethod
+    def from_dict(req_dict):
+        if req_dict is None:
+            return None
+
+        req = PodCreateRequest()
+        req.name = req_dict.get('name')
+        req.mode = req_dict.get('mode')
+        req.details = req_dict.get('details')
+        return req
+
+
+class Pod(PodCreateRequest):
+    """ describes a POD platform """
+    def __init__(self, name='', mode='', details='', _id='', create_date=''):
+        super(Pod, self).__init__(name, mode, details)
+        self._id = _id
+        self.creation_date = create_date
+
+    @staticmethod
+    def pod_from_dict(pod_dict):
+        if pod_dict is None:
+            return None
+
+        p = Pod()
+        p._id = pod_dict.get('_id')
+        p.creation_date = str(pod_dict.get('creation_date'))
+        p.name = pod_dict.get('name')
+        p.mode = pod_dict.get('mode')
+        p.details = pod_dict.get('details')
+        return p
+
+    def format(self):
+        f = super(Pod, self).format()
+        f['creation_date'] = str(self.creation_date)
+        return f
+
+    def format_http(self):
+        f = self.format()
+        f['_id'] = str(self._id)
+        return f
+
+
+class PodCreateResponse(object):
+    def __init__(self, pod=None, meta=None):
+        self.pod = pod
+        self.meta = meta
+
+    @staticmethod
+    def from_dict(res_dict):
+        if res_dict is None:
+            return None
+
+        res = PodCreateResponse()
+        res.pod = Pod.pod_from_dict(res_dict.get('pod'))
+        res.meta = MetaCreateResponse.from_dict(res_dict.get('meta'))
+        return res
+
+
+class PodGetResponse(PodCreateRequest):
+    def __init__(self, name='', mode='', details='', create_date=''):
+        self.creation_date = create_date
+        super(PodGetResponse, self).__init__(name, mode, details)
+
+    @staticmethod
+    def from_dict(req_dict):
+        if req_dict is None:
+            return None
+
+        res = PodGetResponse()
+        res.creation_date = str(req_dict.get('creation_date'))
+        res.name = req_dict.get('name')
+        res.mode = req_dict.get('mode')
+        res.details = req_dict.get('details')
+        return res
+
+
+class PodsGetResponse(object):
+    def __init__(self, pods=[], meta=None):
+        self.pods = pods
+        self.meta = meta
+
+    @staticmethod
+    def from_dict(res_dict):
+        if res_dict is None:
+            return None
+
+        res = PodsGetResponse()
+        for pod in res_dict.get('pods'):
+            res.pods.append(PodGetResponse.from_dict(pod))
+        res.meta = MetaGetResponse.from_dict(res_dict.get('meta'))
+        return res
index e2db460..e5ded37 100644 (file)
@@ -123,6 +123,9 @@ class MemDb(object):
             result = executor.submit(self._remove, spec_or_id)
         return result
 
+    def clear(self):
+        self._remove()
+
 pod = MemDb()
 test_projects = MemDb()
 test_cases = MemDb()
index b72436e..98190fb 100644 (file)
@@ -1,3 +1,4 @@
+import json
 from tornado.web import Application
 from tornado.testing import AsyncHTTPTestCase
 
@@ -7,6 +8,12 @@ import fake_pymongo
 
 
 class TestBase(AsyncHTTPTestCase):
+    headers = {'Content-Type': 'application/json; charset=UTF-8'}
+
+    def setUp(self):
+        self.addCleanup(self._clear)
+        super(TestBase, self).setUp()
+
     def get_app(self):
         return Application(
             [
@@ -28,9 +35,20 @@ class TestBase(AsyncHTTPTestCase):
             debug=True,
         )
 
-    def tearDown(self):
-        yield fake_pymongo.pod.remove()
-        yield fake_pymongo.test_projects.remove()
-        yield fake_pymongo.test_cases.remove()
-        yield fake_pymongo.test_results.remove()
-        super(TestBase, self).tearDown()
+    def create(self, uri, body=None):
+        return self.fetch(uri,
+                          method='POST',
+                          body=json.dumps(body),
+                          headers=self.headers)
+
+    def get(self, uri):
+        return self.fetch(uri,
+                          method='GET',
+                          headers=self.headers)
+
+    @staticmethod
+    def _clear():
+        fake_pymongo.pod.clear()
+        fake_pymongo.test_projects.clear()
+        fake_pymongo.test_cases.clear()
+        fake_pymongo.test_results.clear()
diff --git a/utils/test/result_collection_api/tests/unit/test_pod.py b/utils/test/result_collection_api/tests/unit/test_pod.py
new file mode 100644 (file)
index 0000000..5a3d485
--- /dev/null
@@ -0,0 +1,86 @@
+import unittest
+import json
+
+from test_base import TestBase
+from resources.pod_models import PodCreateRequest, \
+    PodCreateResponse, PodsGetResponse
+from common.constants import HTTP_OK, HTTP_BAD_REQUEST, HTTP_FORBIDDEN
+
+
+class TestPodCreate(TestBase):
+    req = PodCreateRequest(name='zte-1', mode='alive', details='zte pod 1')
+
+    def test_withoutBody(self):
+        res = self.create('/pods', body=None)
+        self.assertEqual(res.code, HTTP_BAD_REQUEST)
+
+    def test_success(self):
+        res = self.create('/pods', body=self.req.format())
+        self.assertEqual(res.code, HTTP_OK)
+        res_body = PodCreateResponse.from_dict(json.loads(res.body))
+        self._assertMeta(res_body.meta, True)
+        self._assertBody(res_body.pod)
+
+    def test_alreadyExist(self):
+        self.create('/pods', body=self.req.format())
+        res = self.create('/pods', body=self.req.format())
+        self.assertEqual(res.code, HTTP_FORBIDDEN)
+        self.assertIn('already exists', res.body)
+
+    def _assertMeta(self, meta, success):
+        self.assertEqual(meta.success, success)
+        if success:
+            self.assertEqual(meta.uri, '/pods/{}'.format(self.req.name))
+
+    def _assertBody(self, res):
+        self.assertEqual(res.name, self.req.name)
+        self.assertEqual(res.mode, self.req.mode)
+        self.assertEqual(res.details, self.req.details)
+        self.assertIsNotNone(res.creation_date)
+        self.assertIsNotNone(res._id)
+
+
+class TestPodGet(TestBase):
+    def test_notExist(self):
+        res = self.get('/pods/notExist')
+        body = PodsGetResponse.from_dict(json.loads(res.body))
+        self._assertMeta(body.meta, 0)
+
+    def test_getOne(self):
+        self.create('/pods', body=TestPodCreate.req.format())
+        res = self.get('/pods/{}'.format(TestPodCreate.req.name))
+        body = PodsGetResponse.from_dict(json.loads(res.body))
+        self._assertMeta(body.meta, 1)
+        self._assertBody(TestPodCreate.req, body.pods[0])
+
+    def test_list(self):
+        req = PodCreateRequest(name='zte-2', mode='alive', details='zte pod 2')
+        self.create('/pods', body=TestPodCreate.req.format())
+        self.create('/pods', body=req.format())
+        res = self.get('/pods')
+        body = PodsGetResponse.from_dict(json.loads(res.body))
+        self._assertMeta(body.meta, 2)
+        for pod in body.pods:
+            if req.name == pod.name:
+                self._assertBody(req, pod)
+            else:
+                self._assertBody(TestPodCreate.req, pod)
+
+    def _assertMeta(self, meta, total):
+        def check_success():
+            if total is 0:
+                return False
+            else:
+                return True
+        self.assertEqual(meta.total, total)
+        self.assertEqual(meta.success, check_success())
+
+    def _assertBody(self, req, res):
+        self.assertEqual(res.name, req.name)
+        self.assertEqual(res.mode, req.mode)
+        self.assertEqual(res.details, req.details)
+        self.assertIsNotNone(res.creation_date)
+
+
+if __name__ == '__main__':
+    unittest.main()