HTTP_BAD_REQUEST = 400
HTTP_FORBIDDEN = 403
HTTP_NOT_FOUND = 404
+HTTP_OK = 200
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
# 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
--- /dev/null
+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
result = executor.submit(self._remove, spec_or_id)
return result
+ def clear(self):
+ self._remove()
+
pod = MemDb()
test_projects = MemDb()
test_cases = MemDb()
+import json
from tornado.web import Application
from tornado.testing import AsyncHTTPTestCase
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(
[
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()
--- /dev/null
+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()