Merge "add vIMS for dahsboard"
[releng.git] / utils / test / result_collection_api / resources / handlers.py
1 ##############################################################################
2 # Copyright (c) 2015 Orange
3 # guyrodrigue.koffi@orange.com / koffirodrigue@gmail.com
4 # All rights reserved. This program and the accompanying materials
5 # are made available under the terms of the Apache License, Version 2.0
6 # which accompanies this distribution, and is available at
7 # http://www.apache.org/licenses/LICENSE-2.0
8 ##############################################################################
9
10 import json
11
12 from tornado.web import RequestHandler, asynchronous, HTTPError
13 from tornado import gen
14 from datetime import datetime, timedelta
15
16 from models import Pod, TestProject, TestCase, TestResult
17 from common.constants import DEFAULT_REPRESENTATION, HTTP_BAD_REQUEST, \
18     HTTP_NOT_FOUND, HTTP_FORBIDDEN
19 from common.config import prepare_put_request
20
21 from dashboard.dashboard_utils import get_dashboard_cases, \
22     check_dashboard_ready_project, check_dashboard_ready_case, \
23     get_dashboard_result
24
25
26 class GenericApiHandler(RequestHandler):
27     """
28     The purpose of this class is to take benefit of inheritance and prepare
29     a set of common functions for
30     the handlers
31     """
32
33     def initialize(self):
34         """ Prepares the database for the entire class """
35         self.db = self.settings["db"]
36
37     def prepare(self):
38         if not (self.request.method == "GET"):
39             if self.request.headers.get("Content-Type") is not None:
40                 if self.request.headers["Content-Type"].startswith(
41                         DEFAULT_REPRESENTATION):
42                     try:
43                         self.json_args = json.loads(self.request.body)
44                     except (ValueError, KeyError, TypeError) as error:
45                         raise HTTPError(HTTP_BAD_REQUEST,
46                                         "Bad Json format [{}]".
47                                         format(error))
48                 else:
49                     self.json_args = None
50
51     def finish_request(self, json_object):
52         self.write(json.dumps(json_object))
53         self.set_header("Content-Type", DEFAULT_REPRESENTATION)
54         self.finish()
55
56
57 class VersionHandler(RequestHandler):
58     """ Display a message for the API version """
59     def get(self):
60         self.write("Collection of test result API, v1")
61
62
63 class PodHandler(GenericApiHandler):
64     """ Handle the requests about the POD Platforms
65     HTTP Methdods :
66         - GET : Get PODS
67         - POST : Create a pod
68         - DELETE : DELETE POD
69     """
70
71     def initialize(self):
72         """ Prepares the database for the entire class """
73         super(PodHandler, self).initialize()
74
75     @asynchronous
76     @gen.coroutine
77     def get(self, pod_name=None):
78         """
79         Get all pods or a single pod
80         :param pod_id:
81         """
82         get_request = dict()
83
84         if pod_name is not None:
85             get_request["name"] = pod_name
86
87         res = []
88         cursor = self.db.pod.find(get_request)
89         while (yield cursor.fetch_next):
90             pod = Pod.pod_from_dict(cursor.next_object())
91             res.append(pod.format())
92
93         meta = dict()
94         meta["total"] = len(res)
95         meta["success"] = True if len(res) > 0 else False
96
97         answer = dict()
98         answer["pods"] = res
99         answer["meta"] = meta
100
101         self.finish_request(answer)
102
103     @asynchronous
104     @gen.coroutine
105     def post(self):
106         """ Create a POD"""
107
108         if self.json_args is None:
109             raise HTTPError(HTTP_BAD_REQUEST)
110
111         query = {"name": self.json_args.get("name")}
112
113         # check for existing name in db
114         mongo_dict = yield self.db.pod.find_one(query)
115         if mongo_dict is not None:
116             raise HTTPError(HTTP_FORBIDDEN,
117                             "{} already exists as a pod".format(
118                                 self.json_args.get("name")))
119
120         pod = Pod.pod_from_dict(self.json_args)
121         pod.creation_date = datetime.now()
122
123         future = self.db.pod.insert(pod.format())
124         result = yield future
125         pod._id = result
126
127         meta = dict()
128         meta["success"] = True
129         meta["uri"] = "/pods/{}".format(pod.name)
130
131         answer = dict()
132         answer["pod"] = pod.format_http()
133         answer["meta"] = meta
134
135         self.finish_request(answer)
136
137     @asynchronous
138     @gen.coroutine
139     def delete(self, pod_name):
140         """ Remove a POD
141
142         # check for an existing pod to be deleted
143         mongo_dict = yield self.db.pod.find_one(
144             {'name': pod_name})
145         pod = TestProject.pod(mongo_dict)
146         if pod is None:
147             raise HTTPError(HTTP_NOT_FOUND,
148                             "{} could not be found as a pod to be deleted"
149                             .format(pod_name))
150
151         # just delete it, or maybe save it elsewhere in a future
152         res = yield self.db.test_projects.remove(
153             {'name': pod_name})
154
155         meta = dict()
156         meta["success"] = True
157         meta["deletion-data"] = res
158
159         answer = dict()
160         answer["meta"] = meta
161
162         self.finish_request(answer)
163         """
164         pass
165
166
167 class TestProjectHandler(GenericApiHandler):
168     """
169     TestProjectHandler Class
170     Handle the requests about the Test projects
171     HTTP Methdods :
172         - GET : Get all test projects and details about a specific one
173         - POST : Add a test project
174         - PUT : Edit test projects information (name and/or description)
175         - DELETE : Remove a test project
176     """
177
178     def initialize(self):
179         """ Prepares the database for the entire class """
180         super(TestProjectHandler, self).initialize()
181
182     @asynchronous
183     @gen.coroutine
184     def get(self, project_name=None):
185         """
186         Get Project(s) info
187         :param project_name:
188         """
189
190         if project_name is None:
191             project_name = ""
192
193         get_request = dict()
194
195         if len(project_name) > 0:
196             get_request["name"] = project_name
197
198         res = []
199         cursor = self.db.test_projects.find(get_request)
200         while (yield cursor.fetch_next):
201             test_project = TestProject.testproject_from_dict(
202                 cursor.next_object())
203             res.append(test_project.format_http())
204
205         meta = dict()
206         meta["total"] = len(res)
207         meta["success"] = True if len(res) > 0 else False
208
209         answer = dict()
210         answer["test_projects"] = res
211         answer["meta"] = meta
212
213         self.finish_request(answer)
214
215     @asynchronous
216     @gen.coroutine
217     def post(self):
218         """ Create a test project"""
219
220         if self.json_args is None:
221             raise HTTPError(HTTP_BAD_REQUEST)
222
223         query = {"name": self.json_args.get("name")}
224
225         # check for name in db
226         mongo_dict = yield self.db.test_projects.find_one(query)
227         if mongo_dict is not None:
228             raise HTTPError(HTTP_FORBIDDEN,
229                             "{} already exists as a project".format(
230                                 self.json_args.get("name")))
231
232         test_project = TestProject.testproject_from_dict(self.json_args)
233         test_project.creation_date = datetime.now()
234
235         future = self.db.test_projects.insert(test_project.format())
236         result = yield future
237         test_project._id = result
238
239         self.finish_request(test_project.format_http())
240
241     @asynchronous
242     @gen.coroutine
243     def put(self, project_name):
244         """ Updates the name and description of a test project"""
245
246         print "PUT request for : {}".format(project_name)
247
248         query = {'name': project_name}
249         mongo_dict = yield self.db.test_projects.find_one(query)
250         test_project = TestProject.testproject_from_dict(mongo_dict)
251         if test_project is None:
252             raise HTTPError(HTTP_NOT_FOUND,
253                             "{} could not be found".format(project_name))
254
255         new_name = self.json_args.get("name")
256         new_description = self.json_args.get("description")
257
258         # check for payload name parameter in db
259         # avoid a request if the project name has not changed in the payload
260         if new_name != test_project.name:
261             mongo_dict = yield self.db.test_projects.find_one(
262                 {"name": new_name})
263             if mongo_dict is not None:
264                 raise HTTPError(HTTP_FORBIDDEN,
265                                 "{} already exists as a project"
266                                 .format(new_name))
267
268         # new dict for changes
269         request = dict()
270         request = prepare_put_request(request,
271                                       "name",
272                                       new_name,
273                                       test_project.name)
274         request = prepare_put_request(request,
275                                       "description",
276                                       new_description,
277                                       test_project.description)
278
279         """ raise exception if there isn't a change """
280         if not request:
281             raise HTTPError(HTTP_FORBIDDEN,
282                             "Nothing to update")
283
284         """ we merge the whole document """
285         edit_request = test_project.format()
286         edit_request.update(request)
287
288         """ Updating the DB """
289         res = yield self.db.test_projects.update({'name': project_name},
290                                                  edit_request)
291         print res
292         edit_request["_id"] = str(test_project._id)
293
294         self.finish_request({"message": "success", "content": edit_request})
295
296     @asynchronous
297     @gen.coroutine
298     def delete(self, project_name):
299         """ Remove a test project"""
300
301         print "DELETE request for : {}".format(project_name)
302
303         # check for an existing project to be deleted
304         mongo_dict = yield self.db.test_projects.find_one(
305             {'name': project_name})
306         test_project = TestProject.testproject_from_dict(mongo_dict)
307         if test_project is None:
308             raise HTTPError(HTTP_NOT_FOUND,
309                             "{} could not be found as a project to be deleted"
310                             .format(project_name))
311
312         # just delete it, or maybe save it elsewhere in a future
313         res = yield self.db.test_projects.remove(
314             {'name': project_name})
315         print res
316
317         self.finish_request({"message": "success"})
318
319
320 class TestCasesHandler(GenericApiHandler):
321     """
322     TestCasesHandler Class
323     Handle the requests about the Test cases for test projects
324     HTTP Methdods :
325         - GET : Get all test cases and details about a specific one
326         - POST : Add a test project
327         - PUT : Edit test projects information (name and/or description)
328     """
329
330     def initialize(self):
331         """ Prepares the database for the entire class """
332         super(TestCasesHandler, self).initialize()
333
334     @asynchronous
335     @gen.coroutine
336     def get(self, project_name, case_name=None):
337         """
338         Get testcases(s) info
339         :param project_name:
340         :param case_name:
341         """
342
343         if case_name is None:
344             case_name = ""
345
346         get_request = dict()
347         get_request["project_name"] = project_name
348
349         if len(case_name) > 0:
350             get_request["name"] = case_name
351
352         res = []
353         cursor = self.db.test_cases.find(get_request)
354         print get_request
355         while (yield cursor.fetch_next):
356                 test_case = TestCase.test_case_from_dict(cursor.next_object())
357                 res.append(test_case.format_http())
358
359         meta = dict()
360         meta["total"] = len(res)
361         meta["success"] = True if len(res) > 0 else False
362
363         answer = dict()
364         answer["test_cases"] = res
365         answer["meta"] = meta
366
367         self.finish_request(answer)
368
369     @asynchronous
370     @gen.coroutine
371     def post(self, project_name):
372         """ Create a test case"""
373
374         print "POST Request for {}".format(project_name)
375
376         if self.json_args is None:
377             raise HTTPError(HTTP_BAD_REQUEST,
378                             "Check your request payload")
379
380         # retrieve test project
381         mongo_dict = yield self.db.test_projects.find_one(
382             {"name": project_name})
383         if mongo_dict is None:
384             raise HTTPError(HTTP_FORBIDDEN,
385                             "Could not find project {}"
386                             .format(project_name))
387
388         # test_project = TestProject.testproject_from_dict(self.json_args)
389
390         case = TestCase.test_case_from_dict(self.json_args)
391         case.project_name = project_name
392         case.creation_date = datetime.now()
393
394         future = self.db.test_cases.insert(case.format())
395         result = yield future
396         case._id = result
397         self.finish_request(case.format_http())
398
399     @asynchronous
400     @gen.coroutine
401     def put(self, project_name, case_name):
402         """
403         Updates the name and description of a test case
404         :raises HTTPError (HTTP_NOT_FOUND, HTTP_FORBIDDEN)
405         """
406
407         print "PUT request for : {}/{}".format(project_name, case_name)
408         case_request = {'project_name': project_name, 'name': case_name}
409
410         # check if there is a case for the project in url parameters
411         mongo_dict = yield self.db.test_cases.find_one(case_request)
412         test_case = TestCase.test_case_from_dict(mongo_dict)
413         if test_case is None:
414             raise HTTPError(HTTP_NOT_FOUND,
415                             "{} could not be found as a {} case to be updated"
416                             .format(case_name, project_name))
417
418         new_name = self.json_args.get("name")
419         new_project_name = self.json_args.get("project_name")
420         new_description = self.json_args.get("description")
421
422         # check if there is not an existing test case
423         # with the name provided in the json payload
424         mongo_dict = yield self.db.test_cases.find_one(
425             {'project_name': new_project_name, 'name': new_name})
426         if mongo_dict is not None:
427             raise HTTPError(HTTP_FORBIDDEN,
428                             "{} already exists as a project"
429                             .format(new_name))
430
431         # new dict for changes
432         request = dict()
433         request = prepare_put_request(request,
434                                       "name",
435                                       new_name,
436                                       test_case.name)
437         request = prepare_put_request(request,
438                                       "project_name",
439                                       new_project_name,
440                                       test_case.project_name)
441         request = prepare_put_request(request,
442                                       "description",
443                                       new_description,
444                                       test_case.description)
445
446         # we raise an exception if there isn't a change
447         if not request:
448             raise HTTPError(HTTP_FORBIDDEN,
449                             "Nothing to update")
450
451         # we merge the whole document """
452         edit_request = test_case.format()
453         edit_request.update(request)
454
455         """ Updating the DB """
456         res = yield self.db.test_cases.update(case_request, edit_request)
457         print res
458         edit_request["_id"] = str(test_case._id)
459
460         self.finish_request({"message": "success", "content": edit_request})
461
462     @asynchronous
463     @gen.coroutine
464     def delete(self, project_name, case_name):
465         """ Remove a test case"""
466
467         print "DELETE request for : {}/{}".format(project_name, case_name)
468         case_request = {'project_name': project_name, 'name': case_name}
469
470         # check for an existing case to be deleted
471         mongo_dict = yield self.db.test_cases.find_one(case_request)
472         test_project = TestProject.testproject_from_dict(mongo_dict)
473         if test_project is None:
474             raise HTTPError(HTTP_NOT_FOUND,
475                             "{}/{} could not be found as a case to be deleted"
476                             .format(project_name, case_name))
477
478         # just delete it, or maybe save it elsewhere in a future
479         res = yield self.db.test_projects.remove(case_request)
480         print res
481
482         self.finish_request({"message": "success"})
483
484
485 class TestResultsHandler(GenericApiHandler):
486     """
487     TestResultsHandler Class
488     Handle the requests about the Test project's results
489     HTTP Methdods :
490         - GET : Get all test results and details about a specific one
491         - POST : Add a test results
492         - DELETE : Remove a test result
493     """
494
495     def initialize(self):
496         """ Prepares the database for the entire class """
497         super(TestResultsHandler, self).initialize()
498         self.name = "test_result"
499
500     @asynchronous
501     @gen.coroutine
502     def get(self, result_id=None):
503         """
504         Retrieve result(s) for a test project on a specific POD.
505         Available filters for this request are :
506          - project : project name
507          - case : case name
508          - pod : pod name
509          - version : platform version (Arno-R1, ...)
510          - installer (fuel, ...)
511          - period : x (x last days)
512
513
514         :param result_id: Get a result by ID
515         :raise HTTPError
516
517         GET /results/project=functest&case=vPing&version=Arno-R1 \
518         &pod=pod_name&period=15
519         => get results with optional filters
520         """
521
522         project_arg = self.get_query_argument("project", None)
523         case_arg = self.get_query_argument("case", None)
524         pod_arg = self.get_query_argument("pod", None)
525         version_arg = self.get_query_argument("version", None)
526         installer_arg = self.get_query_argument("installer", None)
527         period_arg = self.get_query_argument("period", None)
528
529         # prepare request
530         get_request = dict()
531         if result_id is None:
532             if project_arg is not None:
533                 get_request["project_name"] = project_arg
534
535             if case_arg is not None:
536                 get_request["case_name"] = case_arg
537
538             if pod_arg is not None:
539                 get_request["pod_name"] = pod_arg
540
541             if version_arg is not None:
542                 get_request["version"] = version_arg
543
544             if installer_arg is not None:
545                 get_request["installer"] = installer_arg
546
547             if period_arg is not None:
548                 try:
549                     period_arg = int(period_arg)
550                 except:
551                     raise HTTPError(HTTP_BAD_REQUEST)
552
553                 if period_arg > 0:
554                     period = datetime.now() - timedelta(days=period_arg)
555                     obj = {"$gte": period}
556                     get_request["creation_date"] = obj
557         else:
558             get_request["_id"] = result_id
559
560         print get_request
561         res = []
562         # fetching results
563         cursor = self.db.test_results.find(get_request)
564         while (yield cursor.fetch_next):
565             test_result = TestResult.test_result_from_dict(
566                 cursor.next_object())
567             res.append(test_result.format_http())
568
569         # building meta object
570         meta = dict()
571         meta["total"] = len(res)
572
573         # final response object
574         answer = dict()
575         answer["test_results"] = res
576         answer["meta"] = meta
577         self.finish_request(answer)
578
579     @asynchronous
580     @gen.coroutine
581     def post(self):
582         """
583         Create a new test result
584         :return: status of the request
585         :raise HTTPError
586         """
587
588         # check for request payload
589         if self.json_args is None:
590             raise HTTPError(HTTP_BAD_REQUEST)
591
592         # check for missing parameters in the request payload
593         if self.json_args.get("project_name") is None:
594             raise HTTPError(HTTP_BAD_REQUEST)
595         if self.json_args.get("case_name") is None:
596             raise HTTPError(HTTP_BAD_REQUEST)
597         # check for pod_name instead of id,
598         # keeping id for current implementations
599         if self.json_args.get("pod_name") is None:
600             raise HTTPError(HTTP_BAD_REQUEST)
601
602         # TODO : replace checks with jsonschema
603         # check for project
604         mongo_dict = yield self.db.test_projects.find_one(
605             {"name": self.json_args.get("project_name")})
606         if mongo_dict is None:
607             raise HTTPError(HTTP_NOT_FOUND,
608                             "Could not find project [{}] "
609                             .format(self.json_args.get("project_name")))
610
611         # check for case
612         mongo_dict = yield self.db.test_cases.find_one(
613             {"name": self.json_args.get("case_name")})
614         if mongo_dict is None:
615             raise HTTPError(HTTP_NOT_FOUND,
616                             "Could not find case [{}] "
617                             .format(self.json_args.get("case_name")))
618
619         # check for pod
620         mongo_dict = yield self.db.pod.find_one(
621             {"name": self.json_args.get("pod_name")})
622         if mongo_dict is None:
623             raise HTTPError(HTTP_NOT_FOUND,
624                             "Could not find POD [{}] "
625                             .format(self.json_args.get("pod_name")))
626
627         # convert payload to object
628         test_result = TestResult.test_result_from_dict(self.json_args)
629         test_result.creation_date = datetime.now()
630
631         future = self.db.test_results.insert(test_result.format(),
632                                              check_keys=False)
633         result = yield future
634         test_result._id = result
635
636         self.finish_request(test_result.format_http())
637
638
639 class DashboardHandler(GenericApiHandler):
640     """
641     DashboardHandler Class
642     Handle the requests about the Test project's results
643     in a dahboard ready format
644     HTTP Methdods :
645         - GET : Get all test results and details about a specific one
646     """
647     def initialize(self):
648         """ Prepares the database for the entire class """
649         super(DashboardHandler, self).initialize()
650         self.name = "dashboard"
651
652     @asynchronous
653     @gen.coroutine
654     def get(self, result_id=None):
655         """
656         Retrieve dashboard ready result(s) for a test project
657         Available filters for this request are :
658          - project : project name
659          - case : case name
660          - pod : pod name
661          - version : platform version (Arno-R1, ...)
662          - installer (fuel, ...)
663          - period : x (x last days)
664
665
666         :param result_id: Get a result by ID
667         :raise HTTPError
668
669         GET /dashboard?project=functest&case=vPing&version=Arno-R1 \
670         &pod=pod_name&period=15
671         => get results with optional filters
672         """
673
674         project_arg = self.get_query_argument("project", None)
675         case_arg = self.get_query_argument("case", None)
676         pod_arg = self.get_query_argument("pod", None)
677         version_arg = self.get_query_argument("version", None)
678         installer_arg = self.get_query_argument("installer", None)
679         period_arg = self.get_query_argument("period", None)
680
681         # prepare request
682         get_request = dict()
683
684         # /dashboard?project=<>&pod=<>...
685         if (result_id is None):
686             if project_arg is not None:
687                 get_request["project_name"] = project_arg
688
689             if case_arg is not None:
690                 get_request["case_name"] = case_arg
691
692             if pod_arg is not None:
693                 get_request["pod_name"] = pod_arg
694
695             if version_arg is not None:
696                 get_request["version"] = version_arg
697
698             if installer_arg is not None:
699                 get_request["installer"] = installer_arg
700
701             if period_arg is not None:
702                 try:
703                     period_arg = int(period_arg)
704                 except:
705                     raise HTTPError(HTTP_BAD_REQUEST)
706                 if period_arg > 0:
707                     period = datetime.now() - timedelta(days=period_arg)
708                     obj = {"$gte": period}
709                     get_request["creation_date"] = obj
710         else:
711             get_request["_id"] = result_id
712
713         dashboard = []
714
715         # on /dashboard retrieve the list of projects and testcases
716         # ready for dashboard
717         if project_arg is None:
718             raise HTTPError(HTTP_NOT_FOUND,
719                             "error:Project name missing")
720         elif check_dashboard_ready_project(project_arg, "./dashboard"):
721             res = []
722
723             if case_arg is None:
724                 raise HTTPError(
725                     HTTP_NOT_FOUND,
726                     "error:Test case missing for project " + project_arg)
727
728             # special case of status for project
729             if case_arg == "status":
730                 del get_request["case_name"]
731                 # retention time to be agreed
732                 # last five days by default?
733                 # TODO move to DB
734                 period = datetime.now() - timedelta(days=5)
735                 get_request["creation_date"] = {"$gte": period}
736
737             # fetching results
738             cursor = self.db.test_results.find(get_request)
739             while (yield cursor.fetch_next):
740                 test_result = TestResult.test_result_from_dict(
741                     cursor.next_object())
742                 res.append(test_result.format_http())
743
744             if check_dashboard_ready_case(project_arg, case_arg):
745                 dashboard = get_dashboard_result(project_arg, case_arg, res)
746             else:
747                 raise HTTPError(
748                     HTTP_NOT_FOUND,
749                     "error:" + case_arg +
750                     " test case not case dashboard ready on project " +
751                     project_arg)
752
753         else:
754             dashboard.append(
755                 {"error": "Project not recognized or not dashboard ready"})
756             dashboard.append(
757                 {"Dashboard-ready-projects":
758                     get_dashboard_cases("./dashboard")})
759             raise HTTPError(
760                 HTTP_NOT_FOUND,
761                 "error: no dashboard ready data for this project")
762
763         # fetching results
764         # cursor = self.db.test_results.find(get_request)
765         # while (yield cursor.fetch_next):
766         #    test_result = TestResult.test_result_from_dict(
767         #        cursor.next_object())
768         #    res.append(test_result.format_http())
769
770         # building meta object
771         meta = dict()
772
773         # final response object
774         answer = dict()
775         answer["dashboard"] = dashboard
776         answer["meta"] = meta
777         self.finish_request(answer)