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

   1 import functools
   2 import httplib
   3
   4 from opnfv_testapi.common import raises
   5 from opnfv_testapi.resources import handlers
   6 import opnfv_testapi.resources.scenario_models as models
   7 from opnfv_testapi.tornado_swagger import swagger
   8
   9
  10 class GenericScenarioHandler(handlers.GenericApiHandler):
  11     def __init__(self, application, request, **kwargs):
  12         super(GenericScenarioHandler, self).__init__(application,
  13                                                      request,
  14                                                      **kwargs)
  15         self.table = self.db_scenarios
  16         self.table_cls = models.Scenario
  17
  18
  19 class ScenariosCLHandler(GenericScenarioHandler):
  20     @swagger.operation(nickname="queryScenarios")
  21     def get(self):
  22         """
  23             @description: Retrieve scenario(s).
  24             @notes: Retrieve scenario(s)
  25                 Available filters for this request are :
  26                  - name : scenario name
  27
  28                 GET /scenarios?name=scenario_1
  29             @param name: scenario name
  30             @type name: L{string}
  31             @in name: query
  32             @required name: False
  33             @param installer: installer type
  34             @type installer: L{string}
  35             @in installer: query
  36             @required installer: False
  37             @param version: version
  38             @type version: L{string}
  39             @in version: query
  40             @required version: False
  41             @param project: project name
  42             @type project: L{string}
  43             @in project: query
  44             @required project: False
  45             @return 200: all scenarios satisfy queries,
  46                          empty list if no scenario is found
  47             @rtype: L{Scenarios}
  48         """
  49
  50         def _set_query():
  51             query = dict()
  52             elem_query = dict()
  53             for k in self.request.query_arguments.keys():
  54                 v = self.get_query_argument(k)
  55                 if k == 'installer':
  56                     elem_query["installer"] = v
  57                 elif k == 'version':
  58                     elem_query["versions.version"] = v
  59                 elif k == 'project':
  60                     elem_query["versions.projects.project"] = v
  61                 else:
  62                     query[k] = v
  63             if elem_query:
  64                 query['installers'] = {'$elemMatch': elem_query}
  65             return query
  66
  67         self._list(_set_query())
  68
  69     @swagger.operation(nickname="createScenario")
  70     def post(self):
  71         """
  72             @description: create a new scenario by name
  73             @param body: scenario to be created
  74             @type body: L{ScenarioCreateRequest}
  75             @in body: body
  76             @rtype: L{CreateResponse}
  77             @return 200: scenario is created.
  78             @raise 403: scenario already exists
  79             @raise 400:  body or name not provided
  80         """
  81         def query(data):
  82             return {'name': data.name}
  83
  84         def error(data):
  85             message = '{} already exists as a scenario'.format(data.name)
  86             return httplib.FORBIDDEN, message
  87
  88         miss_checks = ['name']
  89         db_checks = [(self.table, False, query, error)]
  90         self._create(miss_checks=miss_checks, db_checks=db_checks)
  91
  92
  93 class ScenarioGURHandler(GenericScenarioHandler):
  94     @swagger.operation(nickname='getScenarioByName')
  95     def get(self, name):
  96         """
  97             @description: get a single scenario by name
  98             @rtype: L{Scenario}
  99             @return 200: scenario exist
 100             @raise 404: scenario not exist
 101         """
 102         self._get_one({'name': name})
 103         pass
 104
 105     @swagger.operation(nickname="updateScenarioByName")
 106     def put(self, name):
 107         """
 108             @description: update a single scenario by name
 109             @param body: fields to be updated
 110             @type body: L{ScenarioUpdateRequest}
 111             @in body: body
 112             @rtype: L{Scenario}
 113             @return 200: update success
 114             @raise 404: scenario not exist
 115             @raise 403: nothing to update
 116         """
 117         query = {'name': name}
 118         db_keys = ['name']
 119         self._update(query, db_keys)
 120
 121     @swagger.operation(nickname="deleteScenarioByName")
 122     def delete(self, name):
 123         """
 124         @description: delete a scenario by name
 125         @return 200: delete success
 126         @raise 404: scenario not exist:
 127         """
 128
 129         query = {'name': name}
 130         self._delete(query)
 131
 132     def _update_query(self, keys, data):
 133         query = dict()
 134         equal = True
 135         if self._is_rename():
 136             new = self._term.get('name')
 137             if data.name != new:
 138                 equal = False
 139                 query['name'] = new
 140
 141         return equal, query
 142
 143     def _update_requests(self, data):
 144         updates = {
 145             ('name', 'update'): self._update_requests_rename,
 146             ('installer', 'add'): self._update_requests_add_installer,
 147             ('installer', 'delete'): self._update_requests_delete_installer,
 148             ('version', 'add'): self._update_requests_add_version,
 149             ('version', 'delete'): self._update_requests_delete_version,
 150             ('owner', 'update'): self._update_requests_change_owner,
 151             ('project', 'add'): self._update_requests_add_project,
 152             ('project', 'delete'): self._update_requests_delete_project,
 153             ('customs', 'add'): self._update_requests_add_customs,
 154             ('customs', 'delete'): self._update_requests_delete_customs,
 155             ('score', 'add'): self._update_requests_add_score,
 156             ('trust_indicator', 'add'): self._update_requests_add_ti,
 157         }
 158
 159         updates[(self._field, self._op)](data)
 160
 161         return data.format()
 162
 163     def _iter_installers(xstep):
 164         @functools.wraps(xstep)
 165         def magic(self, data):
 166             [xstep(self, installer)
 167              for installer in self._filter_installers(data.installers)]
 168         return magic
 169
 170     def _iter_versions(xstep):
 171         @functools.wraps(xstep)
 172         def magic(self, installer):
 173             [xstep(self, version)
 174              for version in (self._filter_versions(installer.versions))]
 175         return magic
 176
 177     def _iter_projects(xstep):
 178         @functools.wraps(xstep)
 179         def magic(self, version):
 180             [xstep(self, project)
 181              for project in (self._filter_projects(version.projects))]
 182         return magic
 183
 184     def _update_requests_rename(self, data):
 185         data.name = self._term.get('name')
 186         if not data.name:
 187             raises.BadRequest("new scenario name is not provided")
 188
 189     def _update_requests_add_installer(self, data):
 190         data.installers.append(models.ScenarioInstaller.from_dict(self._term))
 191
 192     def _update_requests_delete_installer(self, data):
 193         data.installers = self._remove_installers(data.installers)
 194
 195     @_iter_installers
 196     def _update_requests_add_version(self, installer):
 197         installer.versions.append(models.ScenarioVersion.from_dict(self._term))
 198
 199     @_iter_installers
 200     def _update_requests_delete_version(self, installer):
 201         installer.versions = self._remove_versions(installer.versions)
 202
 203     @_iter_installers
 204     @_iter_versions
 205     def _update_requests_change_owner(self, version):
 206         version.owner = self._term.get('owner')
 207
 208     @_iter_installers
 209     @_iter_versions
 210     def _update_requests_add_project(self, version):
 211         version.projects.append(models.ScenarioProject.from_dict(self._term))
 212
 213     @_iter_installers
 214     @_iter_versions
 215     def _update_requests_delete_project(self, version):
 216         version.projects = self._remove_projects(version.projects)
 217
 218     @_iter_installers
 219     @_iter_versions
 220     @_iter_projects
 221     def _update_requests_add_customs(self, project):
 222         project.customs = list(set(project.customs + self._term))
 223
 224     @_iter_installers
 225     @_iter_versions
 226     @_iter_projects
 227     def _update_requests_delete_customs(self, project):
 228         project.customs = filter(
 229             lambda f: f not in self._term,
 230             project.customs)
 231
 232     @_iter_installers
 233     @_iter_versions
 234     @_iter_projects
 235     def _update_requests_add_score(self, project):
 236         project.scores.append(
 237             models.ScenarioScore.from_dict(self._term))
 238
 239     @_iter_installers
 240     @_iter_versions
 241     @_iter_projects
 242     def _update_requests_add_ti(self, project):
 243         project.trust_indicators.append(
 244             models.ScenarioTI.from_dict(self._term))
 245
 246     def _is_rename(self):
 247         return self._field == 'name' and self._op == 'update'
 248
 249     def _remove_installers(self, installers):
 250         return self._remove('installer', installers)
 251
 252     def _filter_installers(self, installers):
 253         return self._filter('installer', installers)
 254
 255     def _remove_versions(self, versions):
 256         return self._remove('version', versions)
 257
 258     def _filter_versions(self, versions):
 259         return self._filter('version', versions)
 260
 261     def _remove_projects(self, projects):
 262         return self._remove('project', projects)
 263
 264     def _filter_projects(self, projects):
 265         return self._filter('project', projects)
 266
 267     def _remove(self, field, fields):
 268         return filter(
 269             lambda f: getattr(f, field) != self._locate.get(field),
 270             fields)
 271
 272     def _filter(self, field, fields):
 273         return filter(
 274             lambda f: getattr(f, field) == self._locate.get(field),
 275             fields)
 276
 277     @property
 278     def _field(self):
 279         return self.json_args.get('field')
 280
 281     @property
 282     def _op(self):
 283         return self.json_args.get('op')
 284
 285     @property
 286     def _locate(self):
 287         return self.json_args.get('locate')
 288
 289     @property
 290     def _term(self):
 291         return self.json_args.get('term')