d5672b4ce5445d30a2f2423e85f200f59ef7e1ae
[csit.git] / resources / tools / report_gen / run_robot_data.py
1 #!/usr/bin/python
2
3 # Copyright (c) 2017 Cisco and/or its affiliates.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
7 #
8 #     http://www.apache.org/licenses/LICENSE-2.0
9 #
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
15
16 """
17 Script extracts interested data (name, documentation, message, status) from
18 robot framework output file (output.xml) and prints in specified format (wiki,
19 html, rst) to defined output file.
20
21 Supported formats:
22  - html
23  - rst
24  - wiki
25
26 :TODO:
27  - md
28
29 :Example:
30
31 run_robot_data.py -i "output.xml" -o "tests.rst" -f "rst" -s 3 -l 2
32
33 The example reads the data from "output.xml", writes the output to "tests.rst"
34 in rst format. It will start on the 3rd level of xml structure and the generated
35 document hierarchy will start on the 2nd level.
36 All test suites will be processed.
37
38 :Example:
39
40 run_robot_data.py -i "output.xml" -o "tests.rst" -f "rst" -r "(.*)(lisp)(.*)"
41
42 The example reads the data from "output.xml", writes the output to "tests.rst"
43 in rst format. It will start on the 1st level of xml structure and the generated
44 document hierarchy will start on the 1st level (default values).
45 Only the test suites which match the given regular expression are processed.
46 """
47
48 import argparse
49 import re
50 import sys
51 import json
52 import string
53
54 from robot.api import ExecutionResult, ResultVisitor
55
56
57 class ExecutionChecker(ResultVisitor):
58     """Class to traverse through the test suite structure.
59
60     The functionality implemented in this class generates a json file. Its
61     structure is:
62
63     [
64         {
65             "level": "Level of the suite, type: str",
66             "title": "Title of the suite, type: str",
67             "doc": "Documentation of the suite, type: str",
68             "table": [
69                 ["TC name", "TC doc", "message or status"],
70                 ["TC name", "TC doc", "message or status"],
71                 ... other test cases ...
72                 ["Name", "Documentation", "Message or Status"]
73             ]
74         },
75         ... other test suites ...
76     ]
77
78     .. note:: The header of the table with TCs is at the and of the table.
79     """
80
81     def __init__(self, args):
82         self.formatting = args.formatting
83
84     def visit_suite(self, suite):
85         """Implements traversing through the suite and its direct children.
86
87         :param suite: Suite to process.
88         :type suite: Suite
89         :returns: Nothing.
90         """
91
92         if self.start_suite(suite) is not False:
93             if suite.tests:
94                 sys.stdout.write(',"tests":[')
95             else:
96                 sys.stdout.write('},')
97
98             suite.suites.visit(self)
99             suite.tests.visit(self)
100
101             if suite.tests:
102                 if "ndrdisc" in suite.longname.lower():
103                     hdr = '["Name","Documentation","Message"]'
104                 else:
105                     hdr = '["Name","Documentation","Status"]'
106                 sys.stdout.write(hdr + ']},')
107
108             self.end_suite(suite)
109
110     def start_suite(self, suite):
111         """Called when suite starts.
112
113         :param suite: Suite to process.
114         :type suite: Suite
115         :returns: Nothing.
116         """
117
118         level = len(suite.longname.split("."))
119         sys.stdout.write('{')
120         sys.stdout.write('"level":"' + str(level) + '",')
121         sys.stdout.write('"title":"' + suite.name.replace('"', "'") + '",')
122         sys.stdout.write('"doc":"' + suite.doc.replace('"', "'").
123                          replace('\n', ' ').replace('\r', '').
124                          replace('*[', ' |br| *[') + '"')
125
126     def end_suite(self, suite):
127         """Called when suite ends.
128
129         :param suite: Suite to process.
130         :type suite: Suite
131         :returns: Nothing.
132         """
133         pass
134
135     def visit_test(self, test):
136         """Implements traversing through the test.
137
138         :param test: Test to process.
139         :type test: Test
140         :returns: Nothing.
141         """
142         if self.start_test(test) is not False:
143             self.end_test(test)
144
145     def start_test(self, test):
146         """Called when test starts.
147
148         :param test: Test to process.
149         :type test: Test
150         :returns: Nothing.
151         """
152
153         name = test.name.replace('"', "'")
154         doc = test.doc.replace('"', "'").replace('\n', ' ').replace('\r', '').\
155             replace('[', ' |br| [')
156         if any("NDRPDRDISC" in tag for tag in test.tags):
157             msg = test.message.replace('\n', ' |br| ').replace('\r', ''). \
158                 replace('"', "'")
159
160             sys.stdout.write('["' + name + '","' + doc + '","' + msg + '"]')
161         else:
162             sys.stdout.write(
163                 '["' + name + '","' + doc + '","' + test.status + '"]')
164
165     def end_test(self, test):
166         """Called when test ends.
167
168         :param test: Test to process.
169         :type test: Test
170         :returns: Nothing.
171         """
172         sys.stdout.write(',')
173
174
175 def do_html(data, args):
176     """Generation of a html file from json data.
177
178     :param data: List of suites from json file.
179     :param args: Parsed arguments.
180     :type data: list of dict
181     :type args: ArgumentParser
182     :returns: Nothing.
183     """
184
185     shift = int(args.level)
186     start = int(args.start)
187
188     output = open(args.output, 'w')
189
190     output.write('<html>')
191     for item in data:
192         if int(item['level']) < start:
193             continue
194         level = str(int(item['level']) - start + shift)
195         output.write('<h' + level + '>' + item['title'].lower() +
196                      '</h' + level + '>')
197         output.write('<p>' + re.sub(r"(\*)(.*?)(\*)", r"<b>\2</b>", item['doc'],
198                                     0, flags=re.MULTILINE).
199                      replace(' |br| ', '<br>') + '</p>')
200         try:
201             output.write(gen_html_table(item['tests']))
202         except KeyError:
203             continue
204     output.write('</html>')
205     output.close()
206
207
208 def gen_html_table(data):
209     """Generates a table with TCs' names, documentation and messages / statuses
210     in html format. There is no css used.
211
212     :param data: Json data representing a table with TCs.
213     :type data: str
214     :returns: Table with TCs' names, documentation and messages / statuses in
215     html format.
216     :rtype: str
217     """
218
219     table = '<table width=100% border=1><tr>'
220     table += '<th width=30%>' + data[-1][0] + '</th>'
221     table += '<th width=50%>' + data[-1][1] + '</th>'
222     table += '<th width=20%>' + data[-1][2] + '</th></tr>'
223
224     for item in data[0:-1]:
225         table += '<tr>'
226         for element in item:
227             table += '<td>' + element.replace(' |br| ', '<br>') + '</td>'
228     table += '</tr></table>'
229
230     return table
231
232
233 def do_rst(data, args):
234     """Generation of a rst file from json data.
235
236     :param data: List of suites from json file.
237     :param args: Parsed arguments.
238     :type data: list of dict
239     :type args: ArgumentParser
240     :returns: Nothing.
241     """
242
243     hdrs = ['=', '-', '`', "'", '.', '~', '*', '+', '^']
244     shift = int(args.level)
245     start = int(args.start)
246
247     output = open(args.output, 'w')
248     output.write('\n.. |br| raw:: html\n\n    <br />\n\n')
249
250     if (args.title):
251         output.write(args.title + '\n' +
252                      hdrs[shift - 1] *
253                      len(args.title) + '\n\n')
254
255     for item in data:
256         if int(item['level']) < start:
257             continue
258         if 'ndrchk' in item['title'].lower():
259             continue
260         output.write(item['title'].lower() + '\n' +
261                      hdrs[int(item['level']) - start + shift] *
262                      len(item['title']) + '\n\n')
263         output.write(item['doc'].replace('*', '**').replace('|br|', '\n\n -') +
264                      '\n\n')
265         try:
266             output.write(gen_rst_table(item['tests']) + '\n\n')
267         except KeyError:
268             continue
269     output.close()
270
271
272 def gen_rst_table(data):
273     """Generates a table with TCs' names, documentation and messages / statuses
274     in rst format.
275
276     :param data: Json data representing a table with TCs.
277     :type data: str
278     :returns: Table with TCs' names, documentation and messages / statuses in
279     rst format.
280     :rtype: str
281     """
282
283     table = []
284     # max size of each column
285     lengths = map(max, zip(*[[len(str(elt)) for elt in item] for item in data]))
286
287     start_of_line = '| '
288     vert_separator = ' | '
289     end_of_line = ' |'
290     line_marker = '-'
291
292     meta_template = vert_separator.join(['{{{{{0}:{{{0}}}}}}}'.format(i)
293                                          for i in range(len(lengths))])
294     template = '{0}{1}{2}'.format(start_of_line, meta_template.format(*lengths),
295                                   end_of_line)
296     # determine top/bottom borders
297     to_separator = string.maketrans('| ', '+-')
298     start_of_line = start_of_line.translate(to_separator)
299     vert_separator = vert_separator.translate(to_separator)
300     end_of_line = end_of_line.translate(to_separator)
301     separator = '{0}{1}{2}'.format(start_of_line, vert_separator.
302                                    join([x * line_marker for x in lengths]),
303                                    end_of_line)
304     # determine header separator
305     th_separator_tr = string.maketrans('-', '=')
306     start_of_line = start_of_line.translate(th_separator_tr)
307     line_marker = line_marker.translate(th_separator_tr)
308     vertical_separator = vert_separator.translate(th_separator_tr)
309     end_of_line = end_of_line.translate(th_separator_tr)
310     th_separator = '{0}{1}{2}'.format(start_of_line, vertical_separator.
311                                       join([x * line_marker for x in lengths]),
312                                       end_of_line)
313     # prepare table
314     table.append(separator)
315     # set table header
316     titles = data[-1]
317     table.append(template.format(*titles))
318     table.append(th_separator)
319     # generate table rows
320     for item in data[0:-2]:
321         desc = re.sub(r'(^ \|br\| )', r'', item[1])
322         table.append(template.format(item[0], desc, item[2]))
323         table.append(separator)
324     desc = re.sub(r'(^ \|br\| )', r'', data[-2][1])
325     table.append(template.format(data[-2][0], desc, data[-2][2]))
326     table.append(separator)
327     return '\n'.join(table)
328
329
330 def do_md(data, args):
331     """Generation of a rst file from json data.
332
333     :param data: List of suites from json file.
334     :param args: Parsed arguments.
335     :type data: list of dict
336     :type args: ArgumentParser
337     :returns: Nothing.
338     """
339     raise NotImplementedError("Export to 'md' format is not implemented.")
340
341
342 def do_wiki(data, args):
343     """Generation of a wiki page from json data.
344
345     :param data: List of suites from json file.
346     :param args: Parsed arguments.
347     :type data: list of dict
348     :type args: ArgumentParser
349     :returns: Nothing.
350     """
351
352     shift = int(args.level)
353     start = int(args.start)
354
355     output = open(args.output, 'w')
356
357     for item in data:
358         if int(item['level']) < start:
359             continue
360         if 'ndrchk' in item['title'].lower():
361             continue
362         mark = "=" * (int(item['level']) - start + shift) + ' '
363         output.write(mark + item['title'].lower() + mark + '\n')
364         output.write(item['doc'].replace('*', "'''").replace('|br|', '\n*') +
365                      '\n')
366         try:
367             output.write(gen_wiki_table(item['tests']) + '\n\n')
368         except KeyError:
369             continue
370     output.close()
371
372
373 def gen_wiki_table(data):
374     """Generates a table with TCs' names, documentation and messages / statuses
375     in wiki format.
376
377     :param data: Json data representing a table with TCs.
378     :type data: str
379     :returns: Table with TCs' names, documentation and messages / statuses in
380     wiki format.
381     :rtype: str
382     """
383
384     table = '{| class="wikitable"\n'
385     header = ""
386     for item in data[-1]:
387         header += '!{}\n'.format(item)
388     table += header
389     for item in data[0:-1]:
390         desc = re.sub(r'(^ \|br\| )', r'', item[1]).replace(' |br| ', '\n\n')
391         msg = item[2].replace(' |br| ', '\n\n')
392         table += '|-\n|{}\n|{}\n|{}\n'.format(item[0], desc, msg)
393     table += '|}\n'
394
395     return table
396
397
398 def process_robot_file(args):
399     """Process data from robot output.xml file and generate defined file type.
400
401     :param args: Parsed arguments.
402     :type args: ArgumentParser
403     :return: Nothing.
404     """
405
406     old_sys_stdout = sys.stdout
407     sys.stdout = open(args.output + '.json', 'w')
408
409     result = ExecutionResult(args.input)
410     checker = ExecutionChecker(args)
411
412     sys.stdout.write('[')
413     result.visit(checker)
414     sys.stdout.write('{}]')
415     sys.stdout.close()
416     sys.stdout = old_sys_stdout
417
418     with open(args.output + '.json', 'r') as json_file:
419         data = json.load(json_file)
420     data.pop(-1)
421
422     if args.regex:
423         results = list()
424         regex = re.compile(args.regex)
425         for item in data:
426             if re.search(regex, item['title'].lower()):
427                 results.append(item)
428     else:
429         results = data
430
431     if args.formatting == 'rst':
432         do_rst(results, args)
433     elif args.formatting == 'wiki':
434         do_wiki(results, args)
435     elif args.formatting == 'html':
436         do_html(results, args)
437     elif args.formatting == 'md':
438         do_md(results, args)
439
440
441 def parse_args():
442     """Parse arguments from cmd line.
443
444     :return: Parsed arguments.
445     :rtype ArgumentParser
446     """
447
448     parser = argparse.ArgumentParser(description=__doc__,
449                                      formatter_class=argparse.
450                                      RawDescriptionHelpFormatter)
451     parser.add_argument("-i", "--input",
452                         required=True,
453                         type=argparse.FileType('r'),
454                         help="Robot XML log file")
455     parser.add_argument("-o", "--output",
456                         type=str,
457                         required=True,
458                         help="Output file")
459     parser.add_argument("-f", "--formatting",
460                         required=True,
461                         choices=['html', 'wiki', 'rst', 'md'],
462                         help="Output file format")
463     parser.add_argument("-s", "--start",
464                         type=int,
465                         default=1,
466                         help="The first level to be taken from xml file")
467     parser.add_argument("-l", "--level",
468                         type=int,
469                         default=1,
470                         help="The level of the first chapter in generated file")
471     parser.add_argument("-r", "--regex",
472                         type=str,
473                         default=None,
474                         help="Regular expression used to select test suites. "
475                              "If None, all test suites are selected.")
476     parser.add_argument("-t", "--title",
477                         type=str,
478                         default=None,
479                         help="Title of the output.")
480
481     return parser.parse_args()
482
483
484 if __name__ == "__main__":
485     sys.exit(process_robot_file(parse_args()))

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.