X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=utils%2Ftest%2Ftestapi%2Fopnfv_testapi%2Fresources%2Fscenario_handlers.py;h=d215d18b9959627d2d24c588ddc276571e9fbd3d;hb=8400f035b9b2460535080722f2cd1b859a35d65b;hp=5d420a56e287f99a048739ef6be3d271de6ac622;hpb=13e3d7e3c2649e7e53ea5578f48cf55f3b45946a;p=releng.git

diff --git a/utils/test/testapi/opnfv_testapi/resources/scenario_handlers.py b/utils/test/testapi/opnfv_testapi/resources/scenario_handlers.py
index 5d420a56e..d215d18b9 100644
--- a/utils/test/testapi/opnfv_testapi/resources/scenario_handlers.py
+++ b/utils/test/testapi/opnfv_testapi/resources/scenario_handlers.py
@@ -15,6 +15,24 @@ class GenericScenarioHandler(handlers.GenericApiHandler):
         self.table = self.db_scenarios
         self.table_cls = models.Scenario
 
+    def set_query(self, locators):
+        query = dict()
+        elem_query = dict()
+        for k, v in locators.iteritems():
+            if k == 'scenario':
+                query['name'] = v
+            elif k == 'installer':
+                elem_query["installer"] = v
+            elif k == 'version':
+                elem_query["versions.version"] = v
+            elif k == 'project':
+                elem_query["versions.projects.project"] = v
+            else:
+                query[k] = v
+        if elem_query:
+            query['installers'] = {'$elemMatch': elem_query}
+        return query
+
 
 class ScenariosCLHandler(GenericScenarioHandler):
     @swagger.operation(nickname="queryScenarios")
@@ -96,21 +114,8 @@ class ScenarioGURHandler(GenericScenarioHandler):
         self._get_one(query={'name': name})
         pass
 
-    @swagger.operation(nickname="updateScenarioByName")
     def put(self, name):
-        """
-            @description: update a single scenario by name
-            @param body: fields to be updated
-            @type body: L{ScenarioUpdateRequest}
-            @in body: body
-            @rtype: L{Scenario}
-            @return 200: update success
-            @raise 404: scenario not exist
-            @raise 403: nothing to update
-        """
-        query = {'name': name}
-        db_keys = ['name']
-        self._update(query=query, db_keys=db_keys)
+        pass
 
     @swagger.operation(nickname="deleteScenarioByName")
     def delete(self, name):
@@ -119,164 +124,481 @@ class ScenarioGURHandler(GenericScenarioHandler):
         @return 200: delete success
         @raise 404: scenario not exist:
         """
-
         self._delete(query={'name': name})
 
-    def _update_query(self, keys, data):
-        query = dict()
-        if self._is_rename():
-            new = self._term.get('name')
-            if data.get('name') != new:
-                query['name'] = new
 
-        return query
+class ScenarioUpdater(object):
+    def __init__(self, data, body=None,
+                 installer=None, version=None, project=None):
+        self.data = data
+        self.body = body
+        self.installer = installer
+        self.version = version
+        self.project = project
 
-    def _update_requests(self, data):
+    def update(self, item, action):
         updates = {
-            ('name', 'update'): self._update_requests_rename,
-            ('installer', 'add'): self._update_requests_add_installer,
-            ('installer', 'delete'): self._update_requests_delete_installer,
-            ('version', 'add'): self._update_requests_add_version,
-            ('version', 'delete'): self._update_requests_delete_version,
-            ('owner', 'update'): self._update_requests_change_owner,
-            ('project', 'add'): self._update_requests_add_project,
-            ('project', 'delete'): self._update_requests_delete_project,
-            ('customs', 'add'): self._update_requests_add_customs,
+            ('scores', 'post'): self._update_requests_add_score,
+            ('trust_indicators', 'post'): self._update_requests_add_ti,
+            ('customs', 'post'): self._update_requests_add_customs,
+            ('customs', 'put'): self._update_requests_update_customs,
             ('customs', 'delete'): self._update_requests_delete_customs,
-            ('score', 'add'): self._update_requests_add_score,
-            ('trust_indicator', 'add'): self._update_requests_add_ti,
+            ('projects', 'post'): self._update_requests_add_projects,
+            ('projects', 'put'): self._update_requests_update_projects,
+            ('projects', 'delete'): self._update_requests_delete_projects,
+            ('owner', 'put'): self._update_requests_change_owner,
         }
+        updates[(item, action)](self.data)
 
-        updates[(self._field, self._op)](data)
+        return self.data.format()
 
-        return data.format()
-
-    def _iter_installers(xstep):
+    def iter_installers(xstep):
         @functools.wraps(xstep)
         def magic(self, data):
             [xstep(self, installer)
              for installer in self._filter_installers(data.installers)]
         return magic
 
-    def _iter_versions(xstep):
+    def iter_versions(xstep):
         @functools.wraps(xstep)
         def magic(self, installer):
             [xstep(self, version)
              for version in (self._filter_versions(installer.versions))]
         return magic
 
-    def _iter_projects(xstep):
+    def iter_projects(xstep):
         @functools.wraps(xstep)
         def magic(self, version):
             [xstep(self, project)
              for project in (self._filter_projects(version.projects))]
         return magic
 
-    def _update_requests_rename(self, data):
-        data.name = self._term.get('name')
-        if not data.name:
-            raises.BadRequest(message.missing('name'))
-
-    def _update_requests_add_installer(self, data):
-        data.installers.append(models.ScenarioInstaller.from_dict(self._term))
-
-    def _update_requests_delete_installer(self, data):
-        data.installers = self._remove_installers(data.installers)
-
-    @_iter_installers
-    def _update_requests_add_version(self, installer):
-        installer.versions.append(models.ScenarioVersion.from_dict(self._term))
-
-    @_iter_installers
-    def _update_requests_delete_version(self, installer):
-        installer.versions = self._remove_versions(installer.versions)
-
-    @_iter_installers
-    @_iter_versions
-    def _update_requests_change_owner(self, version):
-        version.owner = self._term.get('owner')
-
-    @_iter_installers
-    @_iter_versions
-    def _update_requests_add_project(self, version):
-        version.projects.append(models.ScenarioProject.from_dict(self._term))
+    @iter_installers
+    @iter_versions
+    @iter_projects
+    def _update_requests_add_score(self, project):
+        project.scores.append(
+            models.ScenarioScore.from_dict(self.body))
 
-    @_iter_installers
-    @_iter_versions
-    def _update_requests_delete_project(self, version):
-        version.projects = self._remove_projects(version.projects)
+    @iter_installers
+    @iter_versions
+    @iter_projects
+    def _update_requests_add_ti(self, project):
+        project.trust_indicators.append(
+            models.ScenarioTI.from_dict(self.body))
 
-    @_iter_installers
-    @_iter_versions
-    @_iter_projects
+    @iter_installers
+    @iter_versions
+    @iter_projects
     def _update_requests_add_customs(self, project):
-        project.customs = list(set(project.customs + self._term))
+        project.customs = list(set(project.customs + self.body))
+
+    @iter_installers
+    @iter_versions
+    @iter_projects
+    def _update_requests_update_customs(self, project):
+        project.customs = list(set(self.body))
 
-    @_iter_installers
-    @_iter_versions
-    @_iter_projects
+    @iter_installers
+    @iter_versions
+    @iter_projects
     def _update_requests_delete_customs(self, project):
         project.customs = filter(
-            lambda f: f not in self._term,
+            lambda f: f not in self.body,
             project.customs)
 
-    @_iter_installers
-    @_iter_versions
-    @_iter_projects
-    def _update_requests_add_score(self, project):
-        project.scores.append(
-            models.ScenarioScore.from_dict(self._term))
-
-    @_iter_installers
-    @_iter_versions
-    @_iter_projects
-    def _update_requests_add_ti(self, project):
-        project.trust_indicators.append(
-            models.ScenarioTI.from_dict(self._term))
-
-    def _is_rename(self):
-        return self._field == 'name' and self._op == 'update'
+    @iter_installers
+    @iter_versions
+    def _update_requests_add_projects(self, version):
+        exists = list()
+        malformat = list()
+        for n in self.body:
+            try:
+                f_n = models.ScenarioProject.from_dict_with_raise(n)
+                if not any(o.project == f_n.project for o in version.projects):
+                    version.projects.append(f_n)
+                else:
+                    exists.append(n['project'])
+            except Exception as e:
+                malformat.append(e.message)
+        if malformat:
+            raises.BadRequest(message.bad_format(malformat))
+        elif exists:
+            raises.Conflict(message.exist('projects', exists))
+
+    @iter_installers
+    @iter_versions
+    def _update_requests_update_projects(self, version):
+        exists = list()
+        malformat = list()
+        projects = list()
+        for n in self.body:
+            try:
+                f_n = models.ScenarioProject.from_dict_with_raise(n)
+                if not any(o.project == f_n.project for o in projects):
+                    projects.append(models.ScenarioProject.from_dict(n))
+                else:
+                    exists.append(n['project'])
+            except:
+                malformat.append(n)
+        if malformat:
+            raises.BadRequest(message.bad_format(malformat))
+        elif exists:
+            raises.Forbidden(message.exist('projects', exists))
+        version.projects = projects
+
+    @iter_installers
+    @iter_versions
+    def _update_requests_delete_projects(self, version):
+        version.projects = self._remove_projects(version.projects)
 
-    def _remove_installers(self, installers):
-        return self._remove('installer', installers)
+    @iter_installers
+    @iter_versions
+    def _update_requests_change_owner(self, version):
+        version.owner = self.body.get('owner')
 
     def _filter_installers(self, installers):
         return self._filter('installer', installers)
 
-    def _remove_versions(self, versions):
-        return self._remove('version', versions)
-
     def _filter_versions(self, versions):
         return self._filter('version', versions)
 
+    def _filter_projects(self, projects):
+        return self._filter('project', projects)
+
     def _remove_projects(self, projects):
         return self._remove('project', projects)
 
-    def _filter_projects(self, projects):
-        return self._filter('project', projects)
+    def _filter(self, item, items):
+        return filter(
+            lambda f: getattr(f, item) == getattr(self, item),
+            items)
 
     def _remove(self, field, fields):
         return filter(
-            lambda f: getattr(f, field) != self._locate.get(field),
+            lambda f: getattr(f, field) not in self.body,
             fields)
 
-    def _filter(self, field, fields):
-        return filter(
-            lambda f: getattr(f, field) == self._locate.get(field),
-            fields)
 
-    @property
-    def _field(self):
-        return self.json_args.get('field')
+class GenericScenarioUpdateHandler(GenericScenarioHandler):
+    def __init__(self, application, request, **kwargs):
+        super(GenericScenarioUpdateHandler, self).__init__(application,
+                                                           request,
+                                                           **kwargs)
+        self.installer = None
+        self.version = None
+        self.project = None
+        self.item = None
+        self.action = None
+
+    def do_update(self, item, action, locators):
+        self.item = item
+        self.action = action
+        for k, v in locators.iteritems():
+            if not v:
+                v = self.get_query_argument(k)
+                setattr(self, k, v)
+                locators[k] = v
+        self.pure_update(query=self.set_query(locators=locators))
 
-    @property
-    def _op(self):
-        return self.json_args.get('op')
+    def _update_requests(self, data):
+        return ScenarioUpdater(data,
+                               self.json_args,
+                               self.installer,
+                               self.version,
+                               self.project).update(self.item, self.action)
+
+
+class ScenarioScoresHandler(GenericScenarioUpdateHandler):
+    @swagger.operation(nickname="addScoreRecord")
+    def post(self, scenario):
+        """
+        @description: add a new score record
+        @notes: add a new score record to a project
+            POST /api/v1/scenarios/<scenario_name>/scores? \
+                installer=<installer_name>& \
+                version=<version_name>& \
+                project=<project_name>
+        @param body: score to be added
+        @type body: L{ScenarioScore}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @param project: project name
+        @type project: L{string}
+        @in project: query
+        @required project: True
+        @return 200: score is created.
+        @raise 404:  scenario/installer/version/project not existed
+        """
+        self.do_update('scores',
+                       'post',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None,
+                                 'project': None})
+
+
+class ScenarioTIsHandler(GenericScenarioUpdateHandler):
+    @swagger.operation(nickname="addTrustIndicatorRecord")
+    def post(self, scenario):
+        """
+        @description: add a new trust indicator record
+        @notes: add a new trust indicator record to a project
+            POST /api/v1/scenarios/<scenario_name>/trust_indicators? \
+                installer=<installer_name>& \
+                version=<version_name>& \
+                project=<project_name>
+        @param body: trust indicator to be added
+        @type body: L{ScenarioTI}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @param project: project name
+        @type project: L{string}
+        @in project: query
+        @required project: True
+        @return 200: trust indicator is added.
+        @raise 404:  scenario/installer/version/project not existed
+        """
+        self.do_update('trust_indicators',
+                       'post',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None,
+                                 'project': None})
 
-    @property
-    def _locate(self):
-        return self.json_args.get('locate')
 
-    @property
-    def _term(self):
-        return self.json_args.get('term')
+class ScenarioCustomsHandler(GenericScenarioUpdateHandler):
+    @swagger.operation(nickname="addCustomizedTestCases")
+    def post(self, scenario):
+        """
+        @description: add customized test cases
+        @notes: add several test cases to a project
+            POST /api/v1/scenarios/<scenario_name>/customs? \
+                installer=<installer_name>& \
+                version=<version_name>& \
+                project=<project_name>
+        @param body: test cases to be added
+        @type body: C{list} of L{string}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @param project: project name
+        @type project: L{string}
+        @in project: query
+        @required project: True
+        @return 200: test cases are added.
+        @raise 404:  scenario/installer/version/project not existed
+        """
+        self.do_update('customs',
+                       'post',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None,
+                                 'project': None})
+
+    @swagger.operation(nickname="updateCustomizedTestCases")
+    def put(self, scenario):
+        """
+        @description: update customized test cases
+        @notes: substitute all the customized test cases
+            PUT /api/v1/scenarios/<scenario_name>/customs? \
+                installer=<installer_name>& \
+                version=<version_name>& \
+                project=<project_name>
+        @param body: new supported test cases
+        @type body: C{list} of L{string}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @param project: project name
+        @type project: L{string}
+        @in project: query
+        @required project: True
+        @return 200: substitute test cases success.
+        @raise 404:  scenario/installer/version/project not existed
+        """
+        self.do_update('customs',
+                       'put',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None,
+                                 'project': None})
+
+    @swagger.operation(nickname="deleteCustomizedTestCases")
+    def delete(self, scenario):
+        """
+        @description: delete one or several customized test cases
+        @notes: delete one or some customized test cases
+            DELETE /api/v1/scenarios/<scenario_name>/customs? \
+                installer=<installer_name>& \
+                version=<version_name>& \
+                project=<project_name>
+        @param body: test case(s) to be deleted
+        @type body: C{list} of L{string}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @param project: project name
+        @type project: L{string}
+        @in project: query
+        @required project: True
+        @return 200: delete test case(s) success.
+        @raise 404:  scenario/installer/version/project not existed
+        """
+        self.do_update('customs',
+                       'delete',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None,
+                                 'project': None})
+
+
+class ScenarioProjectsHandler(GenericScenarioUpdateHandler):
+    @swagger.operation(nickname="addProjectsUnderScenario")
+    def post(self, scenario):
+        """
+        @description: add projects to scenario
+        @notes: add one or multiple projects
+            POST /api/v1/scenarios/<scenario_name>/projects? \
+                installer=<installer_name>& \
+                version=<version_name>
+        @param body: projects to be added
+        @type body: C{list} of L{ScenarioProject}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @return 200: projects are added.
+        @raise 400: bad schema
+        @raise 409: conflict, project already exists
+        @raise 404:  scenario/installer/version not existed
+        """
+        self.do_update('projects',
+                       'post',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None})
+
+    @swagger.operation(nickname="updateScenarioProjects")
+    def put(self, scenario):
+        """
+        @description: replace all projects
+        @notes: substitute all projects, delete existed ones with new provides
+            PUT /api/v1/scenarios/<scenario_name>/projects? \
+                installer=<installer_name>& \
+                version=<version_name>
+        @param body: new projects
+        @type body: C{list} of L{ScenarioProject}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @return 200: replace projects success.
+        @raise 400: bad schema
+        @raise 404:  scenario/installer/version not existed
+        """
+        self.do_update('projects',
+                       'put',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None})
+
+    @swagger.operation(nickname="deleteProjectsUnderScenario")
+    def delete(self, scenario):
+        """
+        @description: delete one or multiple projects
+        @notes: delete one or multiple projects
+            DELETE /api/v1/scenarios/<scenario_name>/projects? \
+                installer=<installer_name>& \
+                version=<version_name>
+        @param body: projects(names) to be deleted
+        @type body: C{list} of L{string}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @return 200: delete project(s) success.
+        @raise 404:  scenario/installer/version not existed
+        """
+        self.do_update('projects',
+                       'delete',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None})
+
+
+class ScenarioOwnerHandler(GenericScenarioUpdateHandler):
+    @swagger.operation(nickname="changeScenarioOwner")
+    def put(self, scenario):
+        """
+        @description: change scenario owner
+        @notes: substitute all projects, delete existed ones with new provides
+            PUT /api/v1/scenarios/<scenario_name>/owner? \
+                installer=<installer_name>& \
+                version=<version_name>
+        @param body: new owner
+        @type body: L{ScenarioChangeOwnerRequest}
+        @in body: body
+        @param installer: installer type
+        @type installer: L{string}
+        @in installer: query
+        @required installer: True
+        @param version: version
+        @type version: L{string}
+        @in version: query
+        @required version: True
+        @return 200: change owner success.
+        @raise 404:  scenario/installer/version not existed
+        """
+        self.do_update('owner',
+                       'put',
+                       locators={'scenario': scenario,
+                                 'installer': None,
+                                 'version': None})