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
  21 class ResultsCLHandler(GenericResultHandler):
  22     @swagger.operation(nickname="list-all")
  23     def get(self):
  24         """
  25             @description: list all test results consist with query
  26             @return 200: all test results consist with query,
  27                          empty list if no result is found
  28             @rtype: L{TestResults}
  29         """
  30         query = dict()
  31         pod_arg = self.get_query_argument("pod", None)
  32         project_arg = self.get_query_argument("project", None)
  33         case_arg = self.get_query_argument("case", None)
  34         version_arg = self.get_query_argument("version", None)
  35         installer_arg = self.get_query_argument("installer", None)
  36         build_tag_arg = self.get_query_argument("build_tag", None)
  37         scenario_arg = self.get_query_argument("scenario", None)
  38         criteria_arg = self.get_query_argument("criteria", None)
  39         period_arg = self.get_query_argument("period", None)
  40         trust_indicator_arg = self.get_query_argument("trust_indicator", None)
  41
  42         if project_arg is not None:
  43             query["project_name"] = project_arg
  44
  45         if case_arg is not None:
  46             query["case_name"] = case_arg
  47
  48         if pod_arg is not None:
  49             query["pod_name"] = pod_arg
  50
  51         if version_arg is not None:
  52             query["version"] = version_arg
  53
  54         if installer_arg is not None:
  55             query["installer"] = installer_arg
  56
  57         if build_tag_arg is not None:
  58             query["build_tag"] = build_tag_arg
  59
  60         if scenario_arg is not None:
  61             query["scenario"] = scenario_arg
  62
  63         if criteria_arg is not None:
  64             query["criteria_tag"] = criteria_arg
  65
  66         if trust_indicator_arg is not None:
  67             query["trust_indicator_arg"] = trust_indicator_arg
  68
  69         if period_arg is not None:
  70             try:
  71                 period_arg = int(period_arg)
  72             except:
  73                 raise HTTPError(HTTP_BAD_REQUEST)
  74
  75             if period_arg > 0:
  76                 period = datetime.now() - timedelta(days=period_arg)
  77                 obj = {"$gte": str(period)}
  78                 query["creation_date"] = obj
  79
  80         self._list(query)
  81
  82     @swagger.operation(nickname="create")
  83     def post(self):
  84         """
  85             @description: create a test result
  86             @param body: result to be created
  87             @type body: L{ResultCreateRequest}
  88             @in body: body
  89             @rtype: L{TestResult}
  90             @return 200: result is created.
  91             @raise 404: pod/project/testcase not exist
  92             @raise 400: body/pod_name/project_name/case_name not provided
  93         """
  94         def pod_query(data):
  95             return {'name': data.pod_name}
  96
  97         def pod_error(data):
  98             message = 'Could not find pod [{}]'.format(data.pod_name)
  99             return HTTP_NOT_FOUND, message
 100
 101         def project_query(data):
 102             return {'name': data.project_name}
 103
 104         def project_error(data):
 105             message = 'Could not find project [{}]'.format(data.project_name)
 106             return HTTP_NOT_FOUND, message
 107
 108         def testcase_query(data):
 109             return {'project_name': data.project_name, 'name': data.case_name}
 110
 111         def testcase_error(data):
 112             message = 'Could not find testcase [{}] in project [{}]'\
 113                 .format(data.case_name, data.project_name)
 114             return HTTP_NOT_FOUND, message
 115
 116         miss_checks = ['pod_name', 'project_name', 'case_name']
 117         db_checks = [('pods', True, pod_query, pod_error),
 118                      ('projects', True, project_query, project_error),
 119                      ('testcases', True, testcase_query, testcase_error)]
 120         self._create(miss_checks, db_checks)
 121
 122
 123 class ResultsGURHandler(GenericResultHandler):
 124     @swagger.operation(nickname='get-one')
 125     def get(self, result_id):
 126         """
 127             @description: get a single result by result_id
 128             @rtype: L{TestResult}
 129             @return 200: test result exist
 130             @raise 404: test result not exist
 131         """
 132         query = dict()
 133         query["_id"] = ObjectId(result_id)
 134         self._get_one(query)