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

   1 from opnfv_testapi.resources import models
   2 from opnfv_testapi.tornado_swagger import swagger
   3
   4
   5 def list_default(value):
   6     return value if value else list()
   7
   8
   9 def dict_default(value):
  10     return value if value else dict()
  11
  12
  13 @swagger.model()
  14 class ScenarioTI(models.ModelBase):
  15     def __init__(self, date=None, status='silver'):
  16         self.date = date
  17         self.status = status
  18
  19
  20 @swagger.model()
  21 class ScenarioScore(models.ModelBase):
  22     def __init__(self, date=None, score='0'):
  23         self.date = date
  24         self.score = score
  25
  26
  27 @swagger.model()
  28 class ScenarioProject(models.ModelBase):
  29     """
  30         @property customs:
  31         @ptype customs: C{list} of L{string}
  32         @property scores:
  33         @ptype scores: C{list} of L{ScenarioScore}
  34         @property trust_indicators:
  35         @ptype trust_indicators: C{list} of L{ScenarioTI}
  36     """
  37     def __init__(self,
  38                  project='',
  39                  customs=None,
  40                  scores=None,
  41                  trust_indicators=None):
  42         self.project = project
  43         self.customs = list_default(customs)
  44         self.scores = list_default(scores)
  45         self.trust_indicators = list_default(trust_indicators)
  46
  47     @staticmethod
  48     def attr_parser():
  49         return {'scores': ScenarioScore,
  50                 'trust_indicators': ScenarioTI}
  51
  52     def __eq__(self, other):
  53         return [self.project == other.project and
  54                 self._customs_eq(other) and
  55                 self._scores_eq(other) and
  56                 self._ti_eq(other)]
  57
  58     def __ne__(self, other):
  59         return not self.__eq__(other)
  60
  61     def _customs_eq(self, other):
  62         return set(self.customs) == set(other.customs)
  63
  64     def _scores_eq(self, other):
  65         return set(self.scores) == set(other.scores)
  66
  67     def _ti_eq(self, other):
  68         return set(self.trust_indicators) == set(other.trust_indicators)
  69
  70
  71 @swagger.model()
  72 class ScenarioVersion(models.ModelBase):
  73     """
  74         @property projects:
  75         @ptype projects: C{list} of L{ScenarioProject}
  76     """
  77     def __init__(self, owner=None, version=None, projects=None):
  78         self.owner = owner
  79         self.version = version
  80         self.projects = list_default(projects)
  81
  82     @staticmethod
  83     def attr_parser():
  84         return {'projects': ScenarioProject}
  85
  86     def __eq__(self, other):
  87         return [self.version == other.version and
  88                 self.owner == other.owner and
  89                 self._projects_eq(other)]
  90
  91     def __ne__(self, other):
  92         return not self.__eq__(other)
  93
  94     def _projects_eq(self, other):
  95         for s_project in self.projects:
  96             for o_project in other.projects:
  97                 if s_project.project == o_project.project:
  98                     if s_project != o_project:
  99                         return False
 100
 101         return True
 102
 103
 104 @swagger.model()
 105 class ScenarioInstaller(models.ModelBase):
 106     """
 107         @property versions:
 108         @ptype versions: C{list} of L{ScenarioVersion}
 109     """
 110     def __init__(self, installer=None, versions=None):
 111         self.installer = installer
 112         self.versions = list_default(versions)
 113
 114     @staticmethod
 115     def attr_parser():
 116         return {'versions': ScenarioVersion}
 117
 118     def __eq__(self, other):
 119         return [self.installer == other.installer and self._versions_eq(other)]
 120
 121     def __ne__(self, other):
 122         return not self.__eq__(other)
 123
 124     def _versions_eq(self, other):
 125         for s_version in self.versions:
 126             for o_version in other.versions:
 127                 if s_version.version == o_version.version:
 128                     if s_version != o_version:
 129                         return False
 130
 131         return True
 132
 133
 134 @swagger.model()
 135 class ScenarioCreateRequest(models.ModelBase):
 136     """
 137         @property installers:
 138         @ptype installers: C{list} of L{ScenarioInstaller}
 139     """
 140     def __init__(self, name='', installers=None):
 141         self.name = name
 142         self.installers = list_default(installers)
 143
 144     @staticmethod
 145     def attr_parser():
 146         return {'installers': ScenarioInstaller}
 147
 148
 149 @swagger.model()
 150 class Scenario(models.ModelBase):
 151     """
 152         @property installers:
 153         @ptype installers: C{list} of L{ScenarioInstaller}
 154     """
 155     def __init__(self, name='', create_date='', _id='', installers=None):
 156         self.name = name
 157         self._id = _id
 158         self.creation_date = create_date
 159         self.installers = list_default(installers)
 160
 161     @staticmethod
 162     def attr_parser():
 163         return {'installers': ScenarioInstaller}
 164
 165     def __ne__(self, other):
 166         return not self.__eq__(other)
 167
 168     def __eq__(self, other):
 169         return [self.name == other.name and self._installers_eq(other)]
 170
 171     def _installers_eq(self, other):
 172         for s_install in self.installers:
 173             for o_install in other.installers:
 174                 if s_install.installer == o_install.installer:
 175                     if s_install != o_install:
 176                         return False
 177
 178         return True
 179
 180
 181 @swagger.model()
 182 class Scenarios(models.ModelBase):
 183     """
 184         @property scenarios:
 185         @ptype scenarios: C{list} of L{Scenario}
 186     """
 187     def __init__(self):
 188         self.scenarios = list()
 189
 190     @staticmethod
 191     def attr_parser():
 192         return {'scenarios': Scenario}