# which accompanies this distribution, and is available at
# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################
-from datetime import datetime, timedelta
+from datetime import datetime
+from datetime import timedelta
-from bson.objectid import ObjectId
-from tornado.web import HTTPError
+from bson import objectid
-from opnfv_testapi.common.constants import HTTP_BAD_REQUEST, HTTP_NOT_FOUND
-from opnfv_testapi.resources.handlers import GenericApiHandler
-from opnfv_testapi.resources.result_models import TestResult
+from opnfv_testapi.common import config
+from opnfv_testapi.common import message
+from opnfv_testapi.common import raises
+from opnfv_testapi.resources import handlers
+from opnfv_testapi.resources import result_models
from opnfv_testapi.tornado_swagger import swagger
+CONF = config.Config()
-class GenericResultHandler(GenericApiHandler):
+
+class GenericResultHandler(handlers.GenericApiHandler):
def __init__(self, application, request, **kwargs):
super(GenericResultHandler, self).__init__(application,
request,
**kwargs)
self.table = self.db_results
- self.table_cls = TestResult
+ self.table_cls = result_models.TestResult
def get_int(self, key, value):
try:
value = int(value)
except:
- raise HTTPError(HTTP_BAD_REQUEST, '{} must be int'.format(key))
+ raises.BadRequest(message.must_int(key))
return value
def set_query(self):
query = dict()
+ date_range = dict()
+
for k in self.request.query_arguments.keys():
v = self.get_query_argument(k)
if k == 'project' or k == 'pod' or k == 'case':
query['start_date'] = obj
elif k == 'trust_indicator':
query[k + '.current'] = float(v)
- elif k != 'last':
+ elif k == 'from':
+ date_range.update({'$gte': str(v)})
+ elif k == 'to':
+ date_range.update({'$lt': str(v)})
+ elif k != 'last' and k != 'page':
query[k] = v
+ if date_range:
+ query['start_date'] = date_range
+
+ # if $lt is not provided,
+ # empty/None/null/'' start_date will also be returned
+ if 'start_date' in query and '$lt' not in query['start_date']:
+ query['start_date'].update({'$lt': str(datetime.now())})
+
return query
class ResultsCLHandler(GenericResultHandler):
- @swagger.operation(nickname="List all Test Results")
+ @swagger.operation(nickname="queryTestResults")
def get(self):
"""
@description: Retrieve result(s) for a test project
- case : case name
- pod : pod name
- version : platform version (Arno-R1, ...)
- - installer (fuel, ...)
+ - installer : fuel/apex/compass/joid/daisy
- build_tag : Jenkins build tag name
- - period : x (x last days)
+ - period : x last days, incompatible with from/to
+ - from : starting time in 2016-01-01 or 2016-01-01 00:01:23
+ - to : ending time in 2016-01-01 or 2016-01-01 00:01:23
- scenario : the test scenario (previously version)
- criteria : the global criteria status passed or failed
- trust_indicator : evaluate the stability of the test case
@type period: L{string}
@in period: query
@required period: False
+ @param from: i.e. 2016-01-01 or 2016-01-01 00:01:23
+ @type from: L{string}
+ @in from: query
+ @required from: False
+ @param to: i.e. 2016-01-01 or 2016-01-01 00:01:23
+ @type to: L{string}
+ @in to: query
+ @required to: False
@param last: last records stored until now
@type last: L{string}
@in last: query
@required last: False
+ @param page: which page to list
+ @type page: L{int}
+ @in page: query
+ @required page: False
@param trust_indicator: must be float
@type trust_indicator: L{float}
@in trust_indicator: query
@required trust_indicator: False
"""
+ limitations = {'sort': {'_id': -1}}
last = self.get_query_argument('last', 0)
if last is not None:
last = self.get_int('last', last)
+ limitations.update({'last': last})
- self._list(self.set_query(), sort=[('start_date', -1)], last=last)
+ page = self.get_query_argument('page', None)
+ if page is not None:
+ page = self.get_int('page', page)
+ limitations.update({'page': page,
+ 'per_page': CONF.api_results_per_page})
- @swagger.operation(nickname="Create a Test Result")
+ self._list(query=self.set_query(), **limitations)
+
+ @swagger.operation(nickname="createTestResult")
def post(self):
"""
@description: create a test result
@raise 404: pod/project/testcase not exist
@raise 400: body/pod_name/project_name/case_name not provided
"""
- def pod_query(data):
- return {'name': data.pod_name}
-
- def pod_error(data):
- message = 'Could not find pod [{}]'.format(data.pod_name)
- return HTTP_NOT_FOUND, message
-
- def project_query(data):
- return {'name': data.project_name}
-
- def project_error(data):
- message = 'Could not find project [{}]'.format(data.project_name)
- return HTTP_NOT_FOUND, message
+ def pod_query():
+ return {'name': self.json_args.get('pod_name')}
- def testcase_query(data):
- return {'project_name': data.project_name, 'name': data.case_name}
+ def project_query():
+ return {'name': self.json_args.get('project_name')}
- def testcase_error(data):
- message = 'Could not find testcase [{}] in project [{}]'\
- .format(data.case_name, data.project_name)
- return HTTP_NOT_FOUND, message
+ def testcase_query():
+ return {'project_name': self.json_args.get('project_name'),
+ 'name': self.json_args.get('case_name')}
- miss_checks = ['pod_name', 'project_name', 'case_name']
- db_checks = [('pods', True, pod_query, pod_error),
- ('projects', True, project_query, project_error),
- ('testcases', True, testcase_query, testcase_error)]
- self._create(miss_checks, db_checks)
+ miss_fields = ['pod_name', 'project_name', 'case_name']
+ carriers = [('pods', pod_query),
+ ('projects', project_query),
+ ('testcases', testcase_query)]
+ self._create(miss_fields=miss_fields, carriers=carriers)
class ResultsGURHandler(GenericResultHandler):
- @swagger.operation(nickname='Get a Test Result by result_id')
+ @swagger.operation(nickname='getTestResultById')
def get(self, result_id):
"""
@description: get a single result by result_id
@raise 404: test result not exist
"""
query = dict()
- query["_id"] = ObjectId(result_id)
- self._get_one(query)
+ query["_id"] = objectid.ObjectId(result_id)
+ self._get_one(query=query)
- @swagger.operation(nickname="Update a Test Result by result_id")
+ @swagger.operation(nickname="updateTestResultById")
def put(self, result_id):
"""
@description: update a single result by _id
@raise 404: result not exist
@raise 403: nothing to update
"""
- query = {'_id': ObjectId(result_id)}
+ query = {'_id': objectid.ObjectId(result_id)}
db_keys = []
- self._update(query, db_keys)
+ self._update(query=query, db_keys=db_keys)
Code Review / releng.git / blobdiff