utils/test/result_collection_api/resources/result_models.py

   1 from tornado_swagger_ui.tornado_swagger import swagger
   2
   3
   4 @swagger.model()
   5 class ResultCreateRequest(object):
   6     def __init__(self,
   7                  pod_name=None,
   8                  project_name=None,
   9                  case_name=None,
  10                  installer=None,
  11                  version=None,
  12                  start_date=None,
  13                  stop_date=None,
  14                  details=None,
  15                  build_tag=None,
  16                  scenario=None,
  17                  criteria=None,
  18                  trust_indicator=None):
  19         self.pod_name = pod_name
  20         self.project_name = project_name
  21         self.case_name = case_name
  22         self.installer = installer
  23         self.version = version
  24         self.start_date = start_date
  25         self.stop_date = stop_date
  26         self.details = details
  27         self.build_tag = build_tag
  28         self.scenario = scenario
  29         self.criteria = criteria
  30         self.trust_indicator = trust_indicator
  31
  32     def format(self):
  33         return {
  34             "pod_name": self.pod_name,
  35             "project_name": self.project_name,
  36             "case_name": self.case_name,
  37             "installer": self.installer,
  38             "version": self.version,
  39             "start_date": self.start_date,
  40             "stop_date": self.stop_date,
  41             "details": self.details,
  42             "build_tag": self.build_tag,
  43             "scenario": self.scenario,
  44             "criteria": self.criteria,
  45             "trust_indicator": self.trust_indicator
  46         }
  47
  48
  49 @swagger.model()
  50 class TestResult(object):
  51     """
  52         @property trust_indicator: must be int/long/float
  53         @ptype trust_indicator: L{float}
  54     """
  55     def __init__(self, _id=None, case_name=None, project_name=None,
  56                  pod_name=None, installer=None, version=None,
  57                  start_date=None, stop_date=None, details=None,
  58                  build_tag=None, scenario=None, criteria=None,
  59                  trust_indicator=None):
  60         self._id = _id
  61         self.case_name = case_name
  62         self.project_name = project_name
  63         self.pod_name = pod_name
  64         self.installer = installer
  65         self.version = version
  66         self.start_date = start_date
  67         self.stop_date = stop_date
  68         self.details = details
  69         self.build_tag = build_tag
  70         self.scenario = scenario
  71         self.criteria = criteria
  72         self.trust_indicator = trust_indicator
  73
  74     @staticmethod
  75     def from_dict(a_dict):
  76
  77         if a_dict is None:
  78             return None
  79
  80         t = TestResult()
  81         t._id = a_dict.get('_id')
  82         t.case_name = a_dict.get('case_name')
  83         t.pod_name = a_dict.get('pod_name')
  84         t.project_name = a_dict.get('project_name')
  85         t.description = a_dict.get('description')
  86         t.start_date = str(a_dict.get('start_date'))
  87         t.stop_date = str(a_dict.get('stop_date'))
  88         t.details = a_dict.get('details')
  89         t.version = a_dict.get('version')
  90         t.installer = a_dict.get('installer')
  91         t.build_tag = a_dict.get('build_tag')
  92         t.scenario = a_dict.get('scenario')
  93         t.criteria = a_dict.get('criteria')
  94         # 0 < trust indicator < 1
  95         # if bad value =>  set this indicator to 0
  96         t.trust_indicator = a_dict.get('trust_indicator')
  97         if t.trust_indicator is not None:
  98             if isinstance(t.trust_indicator, (int, long, float)):
  99                 if t.trust_indicator < 0:
 100                     t.trust_indicator = 0
 101                 elif t.trust_indicator > 1:
 102                     t.trust_indicator = 1
 103             else:
 104                 t.trust_indicator = 0
 105         else:
 106             t.trust_indicator = 0
 107         return t
 108
 109     def format(self):
 110         return {
 111             "case_name": self.case_name,
 112             "project_name": self.project_name,
 113             "pod_name": self.pod_name,
 114             "description": self.description,
 115             "start_date": str(self.start_date),
 116             "stop_date": str(self.stop_date),
 117             "version": self.version,
 118             "installer": self.installer,
 119             "details": self.details,
 120             "build_tag": self.build_tag,
 121             "scenario": self.scenario,
 122             "criteria": self.criteria,
 123             "trust_indicator": self.trust_indicator
 124         }
 125
 126     def format_http(self):
 127         return {
 128             "_id": str(self._id),
 129             "case_name": self.case_name,
 130             "project_name": self.project_name,
 131             "pod_name": self.pod_name,
 132             "description": self.description,
 133             "start_date": str(self.start_date),
 134             "stop_date": str(self.stop_date),
 135             "version": self.version,
 136             "installer": self.installer,
 137             "details": self.details,
 138             "build_tag": self.build_tag,
 139             "scenario": self.scenario,
 140             "criteria": self.criteria,
 141             "trust_indicator": self.trust_indicator
 142         }
 143
 144
 145 @swagger.model()
 146 class TestResults(object):
 147     """
 148         @property results:
 149         @ptype results: C{list} of L{TestResult}
 150     """
 151     def __init__(self):
 152         self.results = list()
 153
 154     @staticmethod
 155     def from_dict(a_dict):
 156         if a_dict is None:
 157             return None
 158
 159         res = TestResults()
 160         for result in a_dict.get('results'):
 161             res.results.append(TestResult.from_dict(result))
 162         return res