utils/test/testapi/opnfv_testapi/resources/result_handlers.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Orange
   3 # guyrodrigue.koffi@orange.com / koffirodrigue@gmail.com
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9 import logging
  10 from datetime import datetime
  11 from datetime import timedelta
  12 import json
  13
  14 from bson import objectid
  15
  16 from opnfv_testapi.common import config
  17 from opnfv_testapi.common import message
  18 from opnfv_testapi.common import raises
  19 from opnfv_testapi.resources import handlers
  20 from opnfv_testapi.resources import result_models
  21 from opnfv_testapi.tornado_swagger import swagger
  22 from opnfv_testapi.ui.auth import constants as auth_const
  23
  24 CONF = config.Config()
  25
  26
  27 class GenericResultHandler(handlers.GenericApiHandler):
  28     def __init__(self, application, request, **kwargs):
  29         super(GenericResultHandler, self).__init__(application,
  30                                                    request,
  31                                                    **kwargs)
  32         self.table = self.db_results
  33         self.table_cls = result_models.TestResult
  34
  35     def get_int(self, key, value):
  36         try:
  37             value = int(value)
  38         except:
  39             raises.BadRequest(message.must_int(key))
  40         return value
  41
  42     def set_query(self):
  43         query = dict()
  44         date_range = dict()
  45
  46         query['public'] = {'$not': {'$eq': 'false'}}
  47         for k in self.request.query_arguments.keys():
  48             v = self.get_query_argument(k)
  49             if k == 'project' or k == 'pod' or k == 'case':
  50                 query[k + '_name'] = v
  51             elif k == 'period':
  52                 v = self.get_int(k, v)
  53                 if v > 0:
  54                     period = datetime.now() - timedelta(days=v)
  55                     obj = {"$gte": str(period)}
  56                     query['start_date'] = obj
  57             elif k == 'trust_indicator':
  58                 query[k + '.current'] = float(v)
  59             elif k == 'from':
  60                 date_range.update({'$gte': str(v)})
  61             elif k == 'to':
  62                 date_range.update({'$lt': str(v)})
  63             elif k == 'signed':
  64                 openid = self.get_secure_cookie(auth_const.OPENID)
  65                 role = self.get_secure_cookie(auth_const.ROLE)
  66                 logging.info('role:%s', role)
  67                 if role:
  68                     del query['public']
  69                     if role != "reviewer":
  70                         query['user'] = openid
  71             elif k != 'last' and k != 'page':
  72                 query[k] = v
  73             if date_range:
  74                 query['start_date'] = date_range
  75
  76             # if $lt is not provided,
  77             # empty/None/null/'' start_date will also be returned
  78             if 'start_date' in query and '$lt' not in query['start_date']:
  79                 query['start_date'].update({'$lt': str(datetime.now())})
  80
  81         return query
  82
  83
  84 class ResultsCLHandler(GenericResultHandler):
  85     @swagger.operation(nickname="queryTestResults")
  86     def get(self):
  87         """
  88             @description: Retrieve result(s) for a test project
  89                           on a specific pod.
  90             @notes: Retrieve result(s) for a test project on a specific pod.
  91                 Available filters for this request are :
  92                  - project : project name
  93                  - case : case name
  94                  - pod : pod name
  95                  - version : platform version (Arno-R1, ...)
  96                  - installer : fuel/apex/compass/joid/daisy
  97                  - build_tag : Jenkins build tag name
  98                  - period : x last days, incompatible with from/to
  99                  - from : starting time in 2016-01-01 or 2016-01-01 00:01:23
 100                  - to : ending time in 2016-01-01 or 2016-01-01 00:01:23
 101                  - scenario : the test scenario (previously version)
 102                  - criteria : the global criteria status passed or failed
 103                  - trust_indicator : evaluate the stability of the test case
 104                    to avoid running systematically long and stable test case
 105                  - signed : get logined user result
 106
 107                 GET /results/project=functest&case=vPing&version=Arno-R1 \
 108                 &pod=pod_name&period=15&signed
 109             @return 200: all test results consist with query,
 110                          empty list if no result is found
 111             @rtype: L{TestResults}
 112             @param pod: pod name
 113             @type pod: L{string}
 114             @in pod: query
 115             @required pod: False
 116             @param project: project name
 117             @type project: L{string}
 118             @in project: query
 119             @required project: False
 120             @param case: case name
 121             @type case: L{string}
 122             @in case: query
 123             @required case: False
 124             @param version: i.e. Colorado
 125             @type version: L{string}
 126             @in version: query
 127             @required version: False
 128             @param installer: fuel/apex/joid/compass
 129             @type installer: L{string}
 130             @in installer: query
 131             @required installer: False
 132             @param build_tag: i.e. v3.0
 133             @type build_tag: L{string}
 134             @in build_tag: query
 135             @required build_tag: False
 136             @param scenario: i.e. odl
 137             @type scenario: L{string}
 138             @in scenario: query
 139             @required scenario: False
 140             @param criteria: i.e. passed
 141             @type criteria: L{string}
 142             @in criteria: query
 143             @required criteria: False
 144             @param period: last days
 145             @type period: L{string}
 146             @in period: query
 147             @required period: False
 148             @param from: i.e. 2016-01-01 or 2016-01-01 00:01:23
 149             @type from: L{string}
 150             @in from: query
 151             @required from: False
 152             @param to: i.e. 2016-01-01 or 2016-01-01 00:01:23
 153             @type to: L{string}
 154             @in to: query
 155             @required to: False
 156             @param last: last records stored until now
 157             @type last: L{string}
 158             @in last: query
 159             @required last: False
 160             @param page: which page to list
 161             @type page: L{int}
 162             @in page: query
 163             @required page: False
 164             @param trust_indicator: must be float
 165             @type trust_indicator: L{float}
 166             @in trust_indicator: query
 167             @required trust_indicator: False
 168             @param signed: user results or all results
 169             @type signed: L{string}
 170             @in signed: query
 171             @required signed: False
 172         """
 173         limitations = {'sort': {'_id': -1}}
 174         last = self.get_query_argument('last', 0)
 175         if last is not None:
 176             last = self.get_int('last', last)
 177             limitations.update({'last': last})
 178
 179         page = self.get_query_argument('page', None)
 180         if page is not None:
 181             page = self.get_int('page', page)
 182             limitations.update({'page': page,
 183                                 'per_page': CONF.api_results_per_page})
 184
 185         self._list(query=self.set_query(), **limitations)
 186
 187     @swagger.operation(nickname="createTestResult")
 188     def post(self):
 189         """
 190             @description: create a test result
 191             @param body: result to be created
 192             @type body: L{ResultCreateRequest}
 193             @in body: body
 194             @rtype: L{CreateResponse}
 195             @return 200: result is created.
 196             @raise 404: pod/project/testcase not exist
 197             @raise 400: body/pod_name/project_name/case_name not provided
 198         """
 199         self._post()
 200
 201     def _post(self):
 202         def pod_query():
 203             return {'name': self.json_args.get('pod_name')}
 204
 205         def project_query():
 206             return {'name': self.json_args.get('project_name')}
 207
 208         def testcase_query():
 209             return {'project_name': self.json_args.get('project_name'),
 210                     'name': self.json_args.get('case_name')}
 211
 212         miss_fields = ['pod_name', 'project_name', 'case_name']
 213         carriers = [('pods', pod_query),
 214                     ('projects', project_query),
 215                     ('testcases', testcase_query)]
 216
 217         self._create(miss_fields=miss_fields, carriers=carriers)
 218
 219
 220 class ResultsUploadHandler(ResultsCLHandler):
 221     @swagger.operation(nickname="uploadTestResult")
 222     def post(self):
 223         """
 224             @description: upload and create a test result
 225             @param body: result to be created
 226             @type body: L{ResultCreateRequest}
 227             @in body: body
 228             @rtype: L{CreateResponse}
 229             @return 200: result is created.
 230             @raise 404: pod/project/testcase not exist
 231             @raise 400: body/pod_name/project_name/case_name not provided
 232         """
 233         logging.info('file upload')
 234         fileinfo = self.request.files['file'][0]
 235         is_public = self.get_body_argument('public')
 236         logging.warning('public:%s', is_public)
 237         logging.info('results is :%s', fileinfo['filename'])
 238         logging.info('results is :%s', fileinfo['body'])
 239         self.json_args = json.loads(fileinfo['body']).copy()
 240         self.json_args['public'] = is_public
 241
 242         openid = self.get_secure_cookie(auth_const.OPENID)
 243         if openid:
 244             self.json_args['user'] = openid
 245
 246         super(ResultsUploadHandler, self)._post()
 247
 248
 249 class ResultsGURHandler(GenericResultHandler):
 250     @swagger.operation(nickname='getTestResultById')
 251     def get(self, result_id):
 252         """
 253             @description: get a single result by result_id
 254             @rtype: L{TestResult}
 255             @return 200: test result exist
 256             @raise 404: test result not exist
 257         """
 258         query = dict()
 259         query["_id"] = objectid.ObjectId(result_id)
 260         self._get_one(query=query)
 261
 262     @swagger.operation(nickname="updateTestResultById")
 263     def put(self, result_id):
 264         """
 265             @description: update a single result by _id
 266             @param body: fields to be updated
 267             @type body: L{ResultUpdateRequest}
 268             @in body: body
 269             @rtype: L{Result}
 270             @return 200: update success
 271             @raise 404: result not exist
 272             @raise 403: nothing to update
 273         """
 274         query = {'_id': objectid.ObjectId(result_id)}
 275         db_keys = []
 276         self._update(query=query, db_keys=db_keys)