3 from opnfv_testapi.common import message
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
10 class GenericScenarioHandler(handlers.GenericApiHandler):
11 def __init__(self, application, request, **kwargs):
12 super(GenericScenarioHandler, self).__init__(application,
15 self.table = self.db_scenarios
16 self.table_cls = models.Scenario
18 def set_query(self, locators):
21 for k, v in locators.iteritems():
24 elif k == 'installer':
25 elem_query["installer"] = v
27 elem_query["versions.version"] = v
29 elem_query["versions.projects.project"] = v
33 query['installers'] = {'$elemMatch': elem_query}
37 class ScenariosCLHandler(GenericScenarioHandler):
38 @swagger.operation(nickname="queryScenarios")
41 @description: Retrieve scenario(s).
42 @notes: Retrieve scenario(s)
43 Available filters for this request are :
44 - name : scenario name
46 GET /scenarios?name=scenario_1
47 @param name: scenario name
51 @param installer: installer type
52 @type installer: L{string}
54 @required installer: False
55 @param version: version
56 @type version: L{string}
58 @required version: False
59 @param project: project name
60 @type project: L{string}
62 @required project: False
63 @return 200: all scenarios satisfy queries,
64 empty list if no scenario is found
71 for k in self.request.query_arguments.keys():
72 v = self.get_query_argument(k)
74 elem_query["installer"] = v
76 elem_query["versions.version"] = v
78 elem_query["versions.projects.project"] = v
82 query['installers'] = {'$elemMatch': elem_query}
85 self._list(query=_set_query())
87 @swagger.operation(nickname="createScenario")
90 @description: create a new scenario by name
91 @param body: scenario to be created
92 @type body: L{ScenarioCreateRequest}
94 @rtype: L{CreateResponse}
95 @return 200: scenario is created.
96 @raise 403: scenario already exists
97 @raise 400: body or name not provided
100 return {'name': self.json_args.get('name')}
101 miss_fields = ['name']
102 self._create(miss_fields=miss_fields, query=query)
105 class ScenarioGURHandler(GenericScenarioHandler):
106 @swagger.operation(nickname='getScenarioByName')
109 @description: get a single scenario by name
111 @return 200: scenario exist
112 @raise 404: scenario not exist
114 self._get_one(query={'name': name})
120 @swagger.operation(nickname="deleteScenarioByName")
121 def delete(self, name):
123 @description: delete a scenario by name
124 @return 200: delete success
125 @raise 404: scenario not exist:
127 self._delete(query={'name': name})
130 class ScenarioUpdater(object):
131 def __init__(self, data, body=None,
132 installer=None, version=None, project=None):
135 self.installer = installer
136 self.version = version
137 self.project = project
139 def update(self, item, action):
141 ('scores', 'post'): self._update_requests_add_score,
142 ('trust_indicators', 'post'): self._update_requests_add_ti,
143 ('customs', 'post'): self._update_requests_add_customs,
144 ('customs', 'put'): self._update_requests_update_customs,
145 ('customs', 'delete'): self._update_requests_delete_customs,
146 ('projects', 'post'): self._update_requests_add_projects,
147 ('projects', 'put'): self._update_requests_update_projects,
148 ('projects', 'delete'): self._update_requests_delete_projects,
149 ('owner', 'put'): self._update_requests_change_owner,
150 ('versions', 'post'): self._update_requests_add_versions,
151 ('versions', 'put'): self._update_requests_update_versions,
152 ('versions', 'delete'): self._update_requests_delete_versions,
154 updates[(item, action)](self.data)
156 return self.data.format()
158 def iter_installers(xstep):
159 @functools.wraps(xstep)
160 def magic(self, data):
161 [xstep(self, installer)
162 for installer in self._filter_installers(data.installers)]
165 def iter_versions(xstep):
166 @functools.wraps(xstep)
167 def magic(self, installer):
168 [xstep(self, version)
169 for version in (self._filter_versions(installer.versions))]
172 def iter_projects(xstep):
173 @functools.wraps(xstep)
174 def magic(self, version):
175 [xstep(self, project)
176 for project in (self._filter_projects(version.projects))]
182 def _update_requests_add_score(self, project):
183 project.scores.append(
184 models.ScenarioScore.from_dict(self.body))
189 def _update_requests_add_ti(self, project):
190 project.trust_indicators.append(
191 models.ScenarioTI.from_dict(self.body))
196 def _update_requests_add_customs(self, project):
197 project.customs = list(set(project.customs + self.body))
202 def _update_requests_update_customs(self, project):
203 project.customs = list(set(self.body))
208 def _update_requests_delete_customs(self, project):
209 project.customs = filter(
210 lambda f: f not in self.body,
215 def _update_requests_add_projects(self, version):
216 version.projects = self._update_with_body(models.ScenarioProject,
222 def _update_requests_update_projects(self, version):
223 version.projects = self._update_with_body(models.ScenarioProject,
229 def _update_requests_delete_projects(self, version):
230 version.projects = self._remove_projects(version.projects)
234 def _update_requests_change_owner(self, version):
235 version.owner = self.body.get('owner')
238 def _update_requests_add_versions(self, installer):
239 installer.versions = self._update_with_body(models.ScenarioVersion,
244 def _update_requests_update_versions(self, installer):
245 installer.versions = self._update_with_body(models.ScenarioVersion,
250 def _update_requests_delete_versions(self, installer):
251 installer.versions = self._remove_versions(installer.versions)
253 def _update_with_body(self, clazz, field, withs):
256 for new in self.body:
258 format_new = clazz.from_dict_with_raise(new)
259 new_name = getattr(format_new, field)
260 if not any(getattr(o, field) == new_name for o in withs):
261 withs.append(format_new)
263 exists.append(new_name)
264 except Exception as error:
265 malformat.append(error.message)
267 raises.BadRequest(message.bad_format(malformat))
269 raises.Conflict(message.exist('{}s'.format(field), exists))
272 def _filter_installers(self, installers):
273 return self._filter('installer', installers)
275 def _filter_versions(self, versions):
276 return self._filter('version', versions)
278 def _remove_versions(self, versions):
279 return self._remove('version', versions)
281 def _filter_projects(self, projects):
282 return self._filter('project', projects)
284 def _remove_projects(self, projects):
285 return self._remove('project', projects)
287 def _filter(self, item, items):
289 lambda f: getattr(f, item) == getattr(self, item),
292 def _remove(self, field, fields):
294 lambda f: getattr(f, field) not in self.body,
298 class GenericScenarioUpdateHandler(GenericScenarioHandler):
299 def __init__(self, application, request, **kwargs):
300 super(GenericScenarioUpdateHandler, self).__init__(application,
303 self.installer = None
309 def do_update(self, item, action, locators):
312 for k, v in locators.iteritems():
314 v = self.get_query_argument(k)
317 self.pure_update(query=self.set_query(locators=locators))
319 def _update_requests(self, data):
320 return ScenarioUpdater(data,
324 self.project).update(self.item, self.action)
327 class ScenarioScoresHandler(GenericScenarioUpdateHandler):
328 @swagger.operation(nickname="addScoreRecord")
329 def post(self, scenario):
331 @description: add a new score record
332 @notes: add a new score record to a project
333 POST /api/v1/scenarios/<scenario_name>/scores? \
334 installer=<installer_name>& \
335 version=<version_name>& \
336 project=<project_name>
337 @param body: score to be added
338 @type body: L{ScenarioScore}
340 @param installer: installer type
341 @type installer: L{string}
343 @required installer: True
344 @param version: version
345 @type version: L{string}
347 @required version: True
348 @param project: project name
349 @type project: L{string}
351 @required project: True
352 @return 200: score is created.
353 @raise 404: scenario/installer/version/project not existed
355 self.do_update('scores',
357 locators={'scenario': scenario,
363 class ScenarioTIsHandler(GenericScenarioUpdateHandler):
364 @swagger.operation(nickname="addTrustIndicatorRecord")
365 def post(self, scenario):
367 @description: add a new trust indicator record
368 @notes: add a new trust indicator record to a project
369 POST /api/v1/scenarios/<scenario_name>/trust_indicators? \
370 installer=<installer_name>& \
371 version=<version_name>& \
372 project=<project_name>
373 @param body: trust indicator to be added
374 @type body: L{ScenarioTI}
376 @param installer: installer type
377 @type installer: L{string}
379 @required installer: True
380 @param version: version
381 @type version: L{string}
383 @required version: True
384 @param project: project name
385 @type project: L{string}
387 @required project: True
388 @return 200: trust indicator is added.
389 @raise 404: scenario/installer/version/project not existed
391 self.do_update('trust_indicators',
393 locators={'scenario': scenario,
399 class ScenarioCustomsHandler(GenericScenarioUpdateHandler):
400 @swagger.operation(nickname="addCustomizedTestCases")
401 def post(self, scenario):
403 @description: add customized test cases
404 @notes: add several test cases to a project
405 POST /api/v1/scenarios/<scenario_name>/customs? \
406 installer=<installer_name>& \
407 version=<version_name>& \
408 project=<project_name>
409 @param body: test cases to be added
410 @type body: C{list} of L{string}
412 @param installer: installer type
413 @type installer: L{string}
415 @required installer: True
416 @param version: version
417 @type version: L{string}
419 @required version: True
420 @param project: project name
421 @type project: L{string}
423 @required project: True
424 @return 200: test cases are added.
425 @raise 404: scenario/installer/version/project not existed
427 self.do_update('customs',
429 locators={'scenario': scenario,
434 @swagger.operation(nickname="updateCustomizedTestCases")
435 def put(self, scenario):
437 @description: update customized test cases
438 @notes: substitute all the customized test cases
439 PUT /api/v1/scenarios/<scenario_name>/customs? \
440 installer=<installer_name>& \
441 version=<version_name>& \
442 project=<project_name>
443 @param body: new supported test cases
444 @type body: C{list} of L{string}
446 @param installer: installer type
447 @type installer: L{string}
449 @required installer: True
450 @param version: version
451 @type version: L{string}
453 @required version: True
454 @param project: project name
455 @type project: L{string}
457 @required project: True
458 @return 200: substitute test cases success.
459 @raise 404: scenario/installer/version/project not existed
461 self.do_update('customs',
463 locators={'scenario': scenario,
468 @swagger.operation(nickname="deleteCustomizedTestCases")
469 def delete(self, scenario):
471 @description: delete one or several customized test cases
472 @notes: delete one or some customized test cases
473 DELETE /api/v1/scenarios/<scenario_name>/customs? \
474 installer=<installer_name>& \
475 version=<version_name>& \
476 project=<project_name>
477 @param body: test case(s) to be deleted
478 @type body: C{list} of L{string}
480 @param installer: installer type
481 @type installer: L{string}
483 @required installer: True
484 @param version: version
485 @type version: L{string}
487 @required version: True
488 @param project: project name
489 @type project: L{string}
491 @required project: True
492 @return 200: delete test case(s) success.
493 @raise 404: scenario/installer/version/project not existed
495 self.do_update('customs',
497 locators={'scenario': scenario,
503 class ScenarioProjectsHandler(GenericScenarioUpdateHandler):
504 @swagger.operation(nickname="addProjectsUnderScenario")
505 def post(self, scenario):
507 @description: add projects to scenario
508 @notes: add one or multiple projects
509 POST /api/v1/scenarios/<scenario_name>/projects? \
510 installer=<installer_name>& \
511 version=<version_name>
512 @param body: projects to be added
513 @type body: C{list} of L{ScenarioProject}
515 @param installer: installer type
516 @type installer: L{string}
518 @required installer: True
519 @param version: version
520 @type version: L{string}
522 @required version: True
523 @return 200: projects are added.
524 @raise 400: bad schema
525 @raise 409: conflict, project already exists
526 @raise 404: scenario/installer/version not existed
528 self.do_update('projects',
530 locators={'scenario': scenario,
534 @swagger.operation(nickname="updateScenarioProjects")
535 def put(self, scenario):
537 @description: replace all projects
538 @notes: substitute all projects, delete existed ones with new provides
539 PUT /api/v1/scenarios/<scenario_name>/projects? \
540 installer=<installer_name>& \
541 version=<version_name>
542 @param body: new projects
543 @type body: C{list} of L{ScenarioProject}
545 @param installer: installer type
546 @type installer: L{string}
548 @required installer: True
549 @param version: version
550 @type version: L{string}
552 @required version: True
553 @return 200: replace projects success.
554 @raise 400: bad schema
555 @raise 404: scenario/installer/version not existed
557 self.do_update('projects',
559 locators={'scenario': scenario,
563 @swagger.operation(nickname="deleteProjectsUnderScenario")
564 def delete(self, scenario):
566 @description: delete one or multiple projects
567 @notes: delete one or multiple projects
568 DELETE /api/v1/scenarios/<scenario_name>/projects? \
569 installer=<installer_name>& \
570 version=<version_name>
571 @param body: projects(names) to be deleted
572 @type body: C{list} of L{string}
574 @param installer: installer type
575 @type installer: L{string}
577 @required installer: True
578 @param version: version
579 @type version: L{string}
581 @required version: True
582 @return 200: delete project(s) success.
583 @raise 404: scenario/installer/version not existed
585 self.do_update('projects',
587 locators={'scenario': scenario,
592 class ScenarioOwnerHandler(GenericScenarioUpdateHandler):
593 @swagger.operation(nickname="changeScenarioOwner")
594 def put(self, scenario):
596 @description: change scenario owner
597 @notes: substitute all projects, delete existed ones with new provides
598 PUT /api/v1/scenarios/<scenario_name>/owner? \
599 installer=<installer_name>& \
600 version=<version_name>
601 @param body: new owner
602 @type body: L{ScenarioChangeOwnerRequest}
604 @param installer: installer type
605 @type installer: L{string}
607 @required installer: True
608 @param version: version
609 @type version: L{string}
611 @required version: True
612 @return 200: change owner success.
613 @raise 404: scenario/installer/version not existed
615 self.do_update('owner',
617 locators={'scenario': scenario,
622 class ScenarioVersionsHandler(GenericScenarioUpdateHandler):
623 @swagger.operation(nickname="addVersionsUnderScenario")
624 def post(self, scenario):
626 @description: add versions to scenario
627 @notes: add one or multiple versions
628 POST /api/v1/scenarios/<scenario_name>/versions? \
629 installer=<installer_name>
630 @param body: versions to be added
631 @type body: C{list} of L{ScenarioVersion}
633 @param installer: installer type
634 @type installer: L{string}
636 @required installer: True
637 @return 200: versions are added.
638 @raise 400: bad schema
639 @raise 409: conflict, version already exists
640 @raise 404: scenario/installer not exist
642 self.do_update('versions',
644 locators={'scenario': scenario,
647 @swagger.operation(nickname="updateVersionsUnderScenario")
648 def put(self, scenario):
650 @description: replace all versions
651 @notes: substitute all versions as a totality
652 PUT /api/v1/scenarios/<scenario_name>/versions? \
653 installer=<installer_name>
654 @param body: new versions
655 @type body: C{list} of L{ScenarioVersion}
657 @param installer: installer type
658 @type installer: L{string}
660 @required installer: True
661 @return 200: replace versions success.
662 @raise 400: bad schema
663 @raise 404: scenario/installer not exist
665 self.do_update('versions',
667 locators={'scenario': scenario,
670 @swagger.operation(nickname="deleteVersionsUnderScenario")
671 def delete(self, scenario):
673 @description: delete one or multiple versions
674 @notes: delete one or multiple versions
675 DELETE /api/v1/scenarios/<scenario_name>/versions? \
676 installer=<installer_name>
677 @param body: versions(names) to be deleted
678 @type body: C{list} of L{string}
680 @param installer: installer type
681 @type installer: L{string}
683 @required installer: True
684 @return 200: delete versions success.
685 @raise 404: scenario/installer not exist
687 self.do_update('versions',
689 locators={'scenario': scenario,