utils/test/result_collection_api/resources/result_handlers.py

   1 from datetime import datetime, timedelta
   2
   3 from bson.objectid import ObjectId
   4 from tornado.web import HTTPError
   5
   6 from common.constants import HTTP_BAD_REQUEST, HTTP_NOT_FOUND
   7 from resources.handlers import GenericApiHandler
   8 from resources.result_models import TestResult
   9 from tornado_swagger_ui.tornado_swagger import swagger
  10
  11
  12 class GenericResultHandler(GenericApiHandler):
  13     def __init__(self, application, request, **kwargs):
  14         super(GenericResultHandler, self).__init__(application,
  15                                                    request,
  16                                                    **kwargs)
  17         self.table = self.db_results
  18         self.table_cls = TestResult
  19
  20     def set_query(self):
  21         query = dict()
  22         for k in self.request.query_arguments.keys():
  23             v = self.get_query_argument(k)
  24             if k == 'project' or k == 'pod' or k == 'case':
  25                 query[k + '_name'] = v
  26             elif k == 'period':
  27                 try:
  28                     v = int(v)
  29                 except:
  30                     raise HTTPError(HTTP_BAD_REQUEST, 'period must be int')
  31                 if v > 0:
  32                     period = datetime.now() - timedelta(days=v)
  33                     obj = {"$gte": str(period)}
  34                     query['start_date'] = obj
  35             elif k == 'trust_indicator':
  36                 query[k] = float(v)
  37             else:
  38                 query[k] = v
  39         return query
  40
  41
  42 class ResultsCLHandler(GenericResultHandler):
  43     @swagger.operation(nickname="list-all")
  44     def get(self):
  45         """
  46             @description: Retrieve result(s) for a test project
  47                           on a specific pod.
  48             @notes: Retrieve result(s) for a test project on a specific pod.
  49                 Available filters for this request are :
  50                  - project : project name
  51                  - case : case name
  52                  - pod : pod name
  53                  - version : platform version (Arno-R1, ...)
  54                  - installer (fuel, ...)
  55                  - build_tag : Jenkins build tag name
  56                  - period : x (x last days)
  57                  - scenario : the test scenario (previously version)
  58                  - criteria : the global criteria status passed or failed
  59                  - trust_indicator : evaluate the stability of the test case
  60                    to avoid running systematically long and stable test case
  61
  62                 GET /results/project=functest&case=vPing&version=Arno-R1 \
  63                 &pod=pod_name&period=15
  64             @return 200: all test results consist with query,
  65                          empty list if no result is found
  66             @rtype: L{TestResults}
  67             @param pod: pod name
  68             @type pod: L{string}
  69             @in pod: query
  70             @required pod: False
  71             @param project: project name
  72             @type project: L{string}
  73             @in project: query
  74             @required project: True
  75             @param case: case name
  76             @type case: L{string}
  77             @in case: query
  78             @required case: True
  79             @param version: i.e. Colorado
  80             @type version: L{string}
  81             @in version: query
  82             @required version: False
  83             @param installer: fuel/apex/joid/compass
  84             @type installer: L{string}
  85             @in installer: query
  86             @required installer: False
  87             @param build_tag: i.e. v3.0
  88             @type build_tag: L{string}
  89             @in build_tag: query
  90             @required build_tag: False
  91             @param scenario: i.e. odl
  92             @type scenario: L{string}
  93             @in scenario: query
  94             @required scenario: False
  95             @param criteria: i.e. passed
  96             @type criteria: L{string}
  97             @in criteria: query
  98             @required criteria: False
  99             @param period: last days
 100             @type period: L{string}
 101             @in period: query
 102             @required period: False
 103             @param trust_indicator: must be int/long/float
 104             @type trust_indicator: L{string}
 105             @in trust_indicator: query
 106             @required trust_indicator: False
 107         """
 108         self._list(self.set_query())
 109
 110     @swagger.operation(nickname="create")
 111     def post(self):
 112         """
 113             @description: create a test result
 114             @param body: result to be created
 115             @type body: L{ResultCreateRequest}
 116             @in body: body
 117             @rtype: L{TestResult}
 118             @return 200: result is created.
 119             @raise 404: pod/project/testcase not exist
 120             @raise 400: body/pod_name/project_name/case_name not provided
 121         """
 122         def pod_query(data):
 123             return {'name': data.pod_name}
 124
 125         def pod_error(data):
 126             message = 'Could not find pod [{}]'.format(data.pod_name)
 127             return HTTP_NOT_FOUND, message
 128
 129         def project_query(data):
 130             return {'name': data.project_name}
 131
 132         def project_error(data):
 133             message = 'Could not find project [{}]'.format(data.project_name)
 134             return HTTP_NOT_FOUND, message
 135
 136         def testcase_query(data):
 137             return {'project_name': data.project_name, 'name': data.case_name}
 138
 139         def testcase_error(data):
 140             message = 'Could not find testcase [{}] in project [{}]'\
 141                 .format(data.case_name, data.project_name)
 142             return HTTP_NOT_FOUND, message
 143
 144         miss_checks = ['pod_name', 'project_name', 'case_name']
 145         db_checks = [('pods', True, pod_query, pod_error),
 146                      ('projects', True, project_query, project_error),
 147                      ('testcases', True, testcase_query, testcase_error)]
 148         self._create(miss_checks, db_checks)
 149
 150
 151 class ResultsGURHandler(GenericResultHandler):
 152     @swagger.operation(nickname='get-one')
 153     def get(self, result_id):
 154         """
 155             @description: get a single result by result_id
 156             @rtype: L{TestResult}
 157             @return 200: test result exist
 158             @raise 404: test result not exist
 159         """
 160         query = dict()
 161         query["_id"] = ObjectId(result_id)
 162         self._get_one(query)