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