swagger-ize project-apis of testAPI
[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 # feng.xiaowei@zte.com.cn refactor db.pod to db.pods         5-19-2016
9 # feng.xiaowei@zte.com.cn refactor test_project to project   5-19-2016
10 # feng.xiaowei@zte.com.cn refactor response body             5-19-2016
11 # feng.xiaowei@zte.com.cn refactor pod/project response info 5-19-2016
12 # feng.xiaowei@zte.com.cn refactor testcase related handler  5-20-2016
13 # feng.xiaowei@zte.com.cn refactor result related handler    5-23-2016
14 # feng.xiaowei@zte.com.cn refactor dashboard related handler 5-24-2016
15 # feng.xiaowei@zte.com.cn add methods to GenericApiHandler   5-26-2016
16 # feng.xiaowei@zte.com.cn remove PodHandler                  5-26-2016
17 ##############################################################################
18
19 import json
20 from datetime import datetime, timedelta
21
22 from tornado.web import RequestHandler, asynchronous, HTTPError
23 from tornado import gen
24
25 from models import CreateResponse
26 from resources.result_models import TestResult
27 from resources.testcase_models import Testcase
28 from common.constants import DEFAULT_REPRESENTATION, HTTP_BAD_REQUEST, \
29     HTTP_NOT_FOUND, HTTP_FORBIDDEN
30 from common.config import prepare_put_request
31 from dashboard.dashboard_utils import check_dashboard_ready_project, \
32     check_dashboard_ready_case, get_dashboard_result
33
34
35 def format_data(data, cls):
36     cls_data = cls.from_dict(data)
37     return cls_data.format_http()
38
39
40 class GenericApiHandler(RequestHandler):
41     def __init__(self, application, request, **kwargs):
42         super(GenericApiHandler, self).__init__(application, request, **kwargs)
43         self.db = self.settings["db"]
44         self.json_args = None
45         self.table = None
46         self.table_cls = None
47
48     def prepare(self):
49         if self.request.method != "GET" and self.request.method != "DELETE":
50             if self.request.headers.get("Content-Type") is not None:
51                 if self.request.headers["Content-Type"].startswith(
52                         DEFAULT_REPRESENTATION):
53                     try:
54                         self.json_args = json.loads(self.request.body)
55                     except (ValueError, KeyError, TypeError) as error:
56                         raise HTTPError(HTTP_BAD_REQUEST,
57                                         "Bad Json format [{}]".
58                                         format(error))
59
60     def finish_request(self, json_object=None):
61         if json_object:
62             self.write(json.dumps(json_object))
63         self.set_header("Content-Type", DEFAULT_REPRESENTATION)
64         self.finish()
65
66     def _create_response(self, resource):
67         href = self.request.full_url() + '/' + resource
68         return CreateResponse(href=href).format()
69
70     @asynchronous
71     @gen.coroutine
72     def _create(self, error):
73         if self.json_args is None:
74             raise HTTPError(HTTP_BAD_REQUEST, 'no body')
75
76         data = self.table_cls.from_dict(self.json_args)
77         name = data.name
78         if name is None or name == '':
79             raise HTTPError(HTTP_BAD_REQUEST,
80                             '{} name missing'.format(self.table[:-1]))
81
82         exist_data = yield self._eval_db(self.table, 'find_one',
83                                          {"name": name})
84         if exist_data is not None:
85             raise HTTPError(HTTP_FORBIDDEN,
86                             error.format(name, self.table[:-1]))
87         data.creation_date = datetime.now()
88         yield self._eval_db(self.table, 'insert', data.format())
89         self.finish_request(self._create_response(name))
90
91     @asynchronous
92     @gen.coroutine
93     def _list(self, query=None):
94         if query is None:
95             query = {}
96         res = []
97         cursor = self._eval_db(self.table, 'find', query)
98         while (yield cursor.fetch_next):
99             res.append(format_data(cursor.next_object(), self.table_cls))
100         self.finish_request({self.table: res})
101
102     @asynchronous
103     @gen.coroutine
104     def _get_one(self, query):
105         data = yield self._eval_db(self.table, 'find_one', query)
106         if data is None:
107             raise HTTPError(HTTP_NOT_FOUND,
108                             "[{}] not exist in table [{}]"
109                             .format(query, self.table))
110         self.finish_request(format_data(data, self.table_cls))
111
112     @asynchronous
113     @gen.coroutine
114     def _delete(self, query):
115         data = yield self._eval_db(self.table, 'find_one', query)
116         if data is None:
117             raise HTTPError(HTTP_NOT_FOUND,
118                             "[{}] not exit in table [{}]"
119                             .format(query, self.table))
120
121         yield self._eval_db(self.table, 'remove', query)
122         self.finish_request()
123
124     def _eval_db(self, table, method, param):
125         return eval('self.db.%s.%s(param)' % (table, method))
126
127
128 class VersionHandler(GenericApiHandler):
129     """ Display a message for the API version """
130     def get(self):
131         self.finish_request([{'v1': 'basics'}])
132
133
134 class TestcaseHandler(GenericApiHandler):
135     """
136     TestCasesHandler Class
137     Handle the requests about the Test cases for test projects
138     HTTP Methdods :
139         - GET : Get all test cases and details about a specific one
140         - POST : Add a test project
141         - PUT : Edit test projects information (name and/or description)
142     """
143
144     def initialize(self):
145         """ Prepares the database for the entire class """
146         super(TestcaseHandler, self).initialize()
147
148     @asynchronous
149     @gen.coroutine
150     def get(self, project_name, case_name=None):
151         """
152         Get testcases(s) info
153         :param project_name:
154         :param case_name:
155         """
156
157         query = {'project_name': project_name}
158
159         if case_name is not None:
160             query["name"] = case_name
161             answer = yield self.db.testcases.find_one(query)
162             if answer is None:
163                 raise HTTPError(HTTP_NOT_FOUND,
164                                 "{} Not Exist".format(case_name))
165             else:
166                 answer = format_data(answer, Testcase)
167         else:
168             res = []
169             cursor = self.db.testcases.find(query)
170             while (yield cursor.fetch_next):
171                 res.append(format_data(cursor.next_object(), Testcase))
172             answer = {'testcases': res}
173
174         self.finish_request(answer)
175
176     @asynchronous
177     @gen.coroutine
178     def post(self, project_name):
179         """ Create a test case"""
180
181         if self.json_args is None:
182             raise HTTPError(HTTP_BAD_REQUEST,
183                             "Check your request payload")
184
185         # retrieve test project
186         project = yield self.db.projects.find_one(
187             {"name": project_name})
188         if project is None:
189             raise HTTPError(HTTP_FORBIDDEN,
190                             "Could not find project {}"
191                             .format(project_name))
192
193         case_name = self.json_args.get('name')
194         the_testcase = yield self.db.testcases.find_one(
195             {"project_name": project_name, 'name': case_name})
196         if the_testcase:
197             raise HTTPError(HTTP_FORBIDDEN,
198                             "{} already exists as a case in project {}"
199                             .format(case_name, project_name))
200
201         testcase = Testcase.from_dict(self.json_args)
202         testcase.project_name = project_name
203         testcase.creation_date = datetime.now()
204
205         yield self.db.testcases.insert(testcase.format())
206         self.finish_request(self._create_response(testcase.name))
207
208     @asynchronous
209     @gen.coroutine
210     def put(self, project_name, case_name):
211         """
212         Updates the name and description of a test case
213         :raises HTTPError (HTTP_NOT_FOUND, HTTP_FORBIDDEN)
214         """
215
216         query = {'project_name': project_name, 'name': case_name}
217
218         if self.json_args is None:
219             raise HTTPError(HTTP_BAD_REQUEST, "No payload")
220
221         # check if there is a case for the project in url parameters
222         from_testcase = yield self.db.testcases.find_one(query)
223         if from_testcase is None:
224             raise HTTPError(HTTP_NOT_FOUND,
225                             "{} could not be found as a {} case to be updated"
226                             .format(case_name, project_name))
227
228         testcase = Testcase.from_dict(from_testcase)
229         new_name = self.json_args.get("name")
230         new_project_name = self.json_args.get("project_name")
231         if not new_project_name:
232             new_project_name = project_name
233         new_description = self.json_args.get("description")
234
235         # check if there is not an existing test case
236         # with the name provided in the json payload
237         if new_name != case_name or new_project_name != project_name:
238             to_testcase = yield self.db.testcases.find_one(
239                 {'project_name': new_project_name, 'name': new_name})
240             if to_testcase is not None:
241                 raise HTTPError(HTTP_FORBIDDEN,
242                                 "{} already exists as a case in project"
243                                 .format(new_name, new_project_name))
244
245         # new dict for changes
246         request = dict()
247         request = prepare_put_request(request,
248                                       "name",
249                                       new_name,
250                                       testcase.name)
251         request = prepare_put_request(request,
252                                       "project_name",
253                                       new_project_name,
254                                       testcase.project_name)
255         request = prepare_put_request(request,
256                                       "description",
257                                       new_description,
258                                       testcase.description)
259
260         # we raise an exception if there isn't a change
261         if not request:
262             raise HTTPError(HTTP_FORBIDDEN,
263                             "Nothing to update")
264
265         # we merge the whole document """
266         edit_request = testcase.format()
267         edit_request.update(request)
268
269         """ Updating the DB """
270         yield self.db.testcases.update(query, edit_request)
271         new_case = yield self.db.testcases.find_one({"_id": testcase._id})
272         self.finish_request(format_data(new_case, Testcase))
273
274     @asynchronous
275     @gen.coroutine
276     def delete(self, project_name, case_name):
277         """ Remove a test case"""
278
279         query = {'project_name': project_name, 'name': case_name}
280
281         # check for an existing case to be deleted
282         testcase = yield self.db.testcases.find_one(query)
283         if testcase is None:
284             raise HTTPError(HTTP_NOT_FOUND,
285                             "{}/{} could not be found as a case to be deleted"
286                             .format(project_name, case_name))
287
288         # just delete it, or maybe save it elsewhere in a future
289         yield self.db.testcases.remove(query)
290         self.finish_request()
291
292
293 class TestResultsHandler(GenericApiHandler):
294     """
295     TestResultsHandler Class
296     Handle the requests about the Test project's results
297     HTTP Methdods :
298         - GET : Get all test results and details about a specific one
299         - POST : Add a test results
300         - DELETE : Remove a test result
301     """
302
303     def initialize(self):
304         """ Prepares the database for the entire class """
305         super(TestResultsHandler, self).initialize()
306         self.name = "test_result"
307
308     @asynchronous
309     @gen.coroutine
310     def get(self, result_id=None):
311         """
312         Retrieve result(s) for a test project on a specific POD.
313         Available filters for this request are :
314          - project : project name
315          - case : case name
316          - pod : pod name
317          - version : platform version (Arno-R1, ...)
318          - installer (fuel, ...)
319          - build_tag : Jenkins build tag name
320          - period : x (x last days)
321          - scenario : the test scenario (previously version)
322          - criteria : the global criteria status passed or failed
323          - trust_indicator : evaluate the stability of the test case to avoid
324          running systematically long and stable test case
325
326
327         :param result_id: Get a result by ID
328         :raise HTTPError
329
330         GET /results/project=functest&case=vPing&version=Arno-R1 \
331         &pod=pod_name&period=15
332         => get results with optional filters
333         """
334
335         # prepare request
336         query = dict()
337         if result_id is not None:
338             query["_id"] = result_id
339             answer = yield self.db.results.find_one(query)
340             if answer is None:
341                 raise HTTPError(HTTP_NOT_FOUND,
342                                 "test result {} Not Exist".format(result_id))
343             else:
344                 answer = format_data(answer, TestResult)
345         else:
346             pod_arg = self.get_query_argument("pod", None)
347             project_arg = self.get_query_argument("project", None)
348             case_arg = self.get_query_argument("case", None)
349             version_arg = self.get_query_argument("version", None)
350             installer_arg = self.get_query_argument("installer", None)
351             build_tag_arg = self.get_query_argument("build_tag", None)
352             scenario_arg = self.get_query_argument("scenario", None)
353             criteria_arg = self.get_query_argument("criteria", None)
354             period_arg = self.get_query_argument("period", None)
355             trust_indicator_arg = self.get_query_argument("trust_indicator",
356                                                           None)
357
358             if project_arg is not None:
359                 query["project_name"] = project_arg
360
361             if case_arg is not None:
362                 query["case_name"] = case_arg
363
364             if pod_arg is not None:
365                 query["pod_name"] = pod_arg
366
367             if version_arg is not None:
368                 query["version"] = version_arg
369
370             if installer_arg is not None:
371                 query["installer"] = installer_arg
372
373             if build_tag_arg is not None:
374                 query["build_tag"] = build_tag_arg
375
376             if scenario_arg is not None:
377                 query["scenario"] = scenario_arg
378
379             if criteria_arg is not None:
380                 query["criteria_tag"] = criteria_arg
381
382             if trust_indicator_arg is not None:
383                 query["trust_indicator_arg"] = trust_indicator_arg
384
385             if period_arg is not None:
386                 try:
387                     period_arg = int(period_arg)
388                 except:
389                     raise HTTPError(HTTP_BAD_REQUEST)
390
391                 if period_arg > 0:
392                     period = datetime.now() - timedelta(days=period_arg)
393                     obj = {"$gte": str(period)}
394                     query["creation_date"] = obj
395
396             res = []
397             cursor = self.db.results.find(query)
398             while (yield cursor.fetch_next):
399                 res.append(format_data(cursor.next_object(), TestResult))
400             answer = {'results': res}
401
402         self.finish_request(answer)
403
404     @asynchronous
405     @gen.coroutine
406     def post(self):
407         """
408         Create a new test result
409         :return: status of the request
410         :raise HTTPError
411         """
412
413         # check for request payload
414         if self.json_args is None:
415             raise HTTPError(HTTP_BAD_REQUEST, 'no payload')
416
417         result = TestResult.from_dict(self.json_args)
418
419         # check for pod_name instead of id,
420         # keeping id for current implementations
421         if result.pod_name is None:
422             raise HTTPError(HTTP_BAD_REQUEST, 'pod is not provided')
423
424         # check for missing parameters in the request payload
425         if result.project_name is None:
426             raise HTTPError(HTTP_BAD_REQUEST, 'project is not provided')
427
428         if result.case_name is None:
429             raise HTTPError(HTTP_BAD_REQUEST, 'testcase is not provided')
430
431         # TODO : replace checks with jsonschema
432         # check for pod
433         the_pod = yield self.db.pods.find_one({"name": result.pod_name})
434         if the_pod is None:
435             raise HTTPError(HTTP_NOT_FOUND,
436                             "Could not find POD [{}] "
437                             .format(self.json_args.get("pod_name")))
438
439         # check for project
440         the_project = yield self.db.projects.find_one(
441             {"name": result.project_name})
442         if the_project is None:
443             raise HTTPError(HTTP_NOT_FOUND, "Could not find project [{}] "
444                             .format(result.project_name))
445
446         # check for testcase
447         the_testcase = yield self.db.testcases.find_one(
448             {"name": result.case_name})
449         if the_testcase is None:
450             raise HTTPError(HTTP_NOT_FOUND,
451                             "Could not find testcase [{}] "
452                             .format(result.case_name))
453
454         _id = yield self.db.results.insert(result.format(), check_keys=False)
455
456         self.finish_request(self._create_response(_id))
457
458
459 class DashboardHandler(GenericApiHandler):
460     """
461     DashboardHandler Class
462     Handle the requests about the Test project's results
463     in a dahboard ready format
464     HTTP Methdods :
465         - GET : Get all test results and details about a specific one
466     """
467     def initialize(self):
468         """ Prepares the database for the entire class """
469         super(DashboardHandler, self).initialize()
470         self.name = "dashboard"
471
472     @asynchronous
473     @gen.coroutine
474     def get(self):
475         """
476         Retrieve dashboard ready result(s) for a test project
477         Available filters for this request are :
478          - project : project name
479          - case : case name
480          - pod : pod name
481          - version : platform version (Arno-R1, ...)
482          - installer (fuel, ...)
483          - period : x (x last days)
484
485
486         :param result_id: Get a result by ID
487         :raise HTTPError
488
489         GET /dashboard?project=functest&case=vPing&version=Arno-R1 \
490         &pod=pod_name&period=15
491         => get results with optional filters
492         """
493
494         project_arg = self.get_query_argument("project", None)
495         case_arg = self.get_query_argument("case", None)
496         pod_arg = self.get_query_argument("pod", None)
497         version_arg = self.get_query_argument("version", None)
498         installer_arg = self.get_query_argument("installer", None)
499         period_arg = self.get_query_argument("period", None)
500
501         # prepare request
502         query = dict()
503
504         if project_arg is not None:
505             query["project_name"] = project_arg
506
507         if case_arg is not None:
508             query["case_name"] = case_arg
509
510         if pod_arg is not None:
511             query["pod_name"] = pod_arg
512
513         if version_arg is not None:
514             query["version"] = version_arg
515
516         if installer_arg is not None:
517             query["installer"] = installer_arg
518
519         if period_arg is not None:
520             try:
521                 period_arg = int(period_arg)
522             except:
523                 raise HTTPError(HTTP_BAD_REQUEST)
524             if period_arg > 0:
525                 period = datetime.now() - timedelta(days=period_arg)
526                 obj = {"$gte": str(period)}
527                 query["creation_date"] = obj
528
529         # on /dashboard retrieve the list of projects and testcases
530         # ready for dashboard
531         if project_arg is None:
532             raise HTTPError(HTTP_NOT_FOUND, "Project name missing")
533
534         if not check_dashboard_ready_project(project_arg):
535             raise HTTPError(HTTP_NOT_FOUND,
536                             'Project [{}] not dashboard ready'
537                             .format(project_arg))
538
539         if case_arg is None:
540             raise HTTPError(
541                 HTTP_NOT_FOUND,
542                 'Test case missing for project [{}]'.format(project_arg))
543
544         if not check_dashboard_ready_case(project_arg, case_arg):
545             raise HTTPError(
546                 HTTP_NOT_FOUND,
547                 'Test case [{}] not dashboard ready for project [{}]'
548                 .format(case_arg, project_arg))
549
550         # special case of status for project
551         res = []
552         if case_arg != "status":
553             cursor = self.db.results.find(query)
554             while (yield cursor.fetch_next):
555                 result = TestResult.from_dict(cursor.next_object())
556                 res.append(result.format_http())
557
558         # final response object
559         self.finish_request(get_dashboard_result(project_arg, case_arg, res))