1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
#!/usr/bin/env python2
#
# Copyright 2016 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Test for generate_report.py."""
from __future__ import division
from __future__ import print_function
from StringIO import StringIO
import copy
import json
import mock
import test_flag
import unittest
import generate_report
import results_report
class _ContextualStringIO(StringIO):
"""StringIO that can be used in `with` statements."""
def __init__(self, *args):
StringIO.__init__(self, *args)
def __enter__(self):
return self
def __exit__(self, _type, _value, _traceback):
pass
class GenerateReportTests(unittest.TestCase):
"""Tests for generate_report.py."""
def testCountBenchmarks(self):
runs = {
'foo': [[{}, {}, {}], [{}, {}, {}, {}]],
'bar': [],
'baz': [[], [{}], [{}, {}, {}]]
}
results = generate_report.CountBenchmarks(runs)
expected_results = [('foo', 4), ('bar', 0), ('baz', 3)]
self.assertItemsEqual(expected_results, results)
def testCutResultsInPlace(self):
bench_data = {
'foo': [[{'a': 1, 'b': 2, 'c': 3}, {'a': 3, 'b': 2.5, 'c': 1}]],
'bar': [[{'d': 11, 'e': 12, 'f': 13}]],
'baz': [[{'g': 12, 'h': 13}]],
'qux': [[{'i': 11}]],
}
original_bench_data = copy.deepcopy(bench_data)
max_keys = 2
results = generate_report.CutResultsInPlace(bench_data, max_keys=max_keys,
complain_on_update=False)
# Cuts should be in-place.
self.assertIs(results, bench_data)
self.assertItemsEqual(original_bench_data.keys(), bench_data.keys())
for bench_name, original_runs in original_bench_data.iteritems():
bench_runs = bench_data[bench_name]
self.assertEquals(len(original_runs), len(bench_runs))
# Order of these sub-lists shouldn't have changed.
for original_list, new_list in zip(original_runs, bench_runs):
self.assertEqual(len(original_list), len(new_list))
for original_keyvals, sub_keyvals in zip(original_list, new_list):
# sub_keyvals must be a subset of original_keyvals
self.assertDictContainsSubset(sub_keyvals, original_keyvals)
def testCutResultsInPlaceLeavesRetval(self):
bench_data = {
'foo': [[{'retval': 0, 'a': 1}]],
'bar': [[{'retval': 1}]],
'baz': [[{'RETVAL': 1}]],
}
results = generate_report.CutResultsInPlace(bench_data, max_keys=0,
complain_on_update=False)
# Just reach into results assuming we know it otherwise outputs things
# sanely. If it doesn't, testCutResultsInPlace should give an indication as
# to what, exactly, is broken.
self.assertEqual(results['foo'][0][0].items(), [('retval', 0)])
self.assertEqual(results['bar'][0][0].items(), [('retval', 1)])
self.assertEqual(results['baz'][0][0].items(), [])
def _RunMainWithInput(self, args, input_obj):
assert '-i' not in args
args += ['-i', '-']
input_buf = _ContextualStringIO(json.dumps(input_obj))
with mock.patch('generate_report.PickInputFile', return_value=input_buf) \
as patched_pick:
result = generate_report.Main(args)
patched_pick.assert_called_once_with('-')
return result
@mock.patch('generate_report.RunActions')
def testMain(self, mock_run_actions):
# Email is left out because it's a bit more difficult to test, and it'll be
# mildly obvious if it's failing.
args = ['--json', '--html', '--text']
return_code = self._RunMainWithInput(args, {'platforms': [], 'data': {}})
self.assertEqual(0, return_code)
self.assertEqual(mock_run_actions.call_count, 1)
ctors = [ctor for ctor, _ in mock_run_actions.call_args[0][0]]
self.assertItemsEqual(ctors, [
results_report.JSONResultsReport,
results_report.TextResultsReport,
results_report.HTMLResultsReport,
])
@mock.patch('generate_report.RunActions')
def testMainSelectsHTMLIfNoReportsGiven(self, mock_run_actions):
args = []
return_code = self._RunMainWithInput(args, {'platforms': [], 'data': {}})
self.assertEqual(0, return_code)
self.assertEqual(mock_run_actions.call_count, 1)
ctors = [ctor for ctor, _ in mock_run_actions.call_args[0][0]]
self.assertItemsEqual(ctors, [results_report.HTMLResultsReport])
# We only mock print_exc so we don't have exception info printed to stdout.
@mock.patch('generate_report.WriteFile', side_effect=ValueError('Oh noo'))
@mock.patch('traceback.print_exc')
def testRunActionsRunsAllActionsRegardlessOfExceptions(self, mock_print_exc,
mock_write_file):
actions = [(None, 'json'), (None, 'html'), (None, 'text'), (None, 'email')]
output_prefix = '-'
ok = generate_report.RunActions(actions, {}, output_prefix, overwrite=False,
verbose=False)
self.assertFalse(ok)
self.assertEqual(mock_write_file.call_count, len(actions))
self.assertEqual(mock_print_exc.call_count, len(actions))
@mock.patch('generate_report.WriteFile')
def testRunActionsReturnsTrueIfAllActionsSucceed(self, mock_write_file):
actions = [(None, 'json'), (None, 'html'), (None, 'text')]
output_prefix = '-'
ok = generate_report.RunActions(actions, {}, output_prefix, overwrite=False,
verbose=False)
self.assertEqual(mock_write_file.call_count, len(actions))
self.assertTrue(ok)
if __name__ == '__main__':
test_flag.SetTestMode(True)
unittest.main()
|
