Debian Codegraph @

Lib/unittest/runner.py

raw
1 """Running tests"""
2
3 import sys
4 import time
5 import warnings
6
7 from _colorize import get_theme
8
9 from . import result
10 from .case import _SubTest
11 from .signals import registerResult
12
13 __unittest = True
14
15
16 class _WritelnDecorator(object):
17 """Used to decorate file-like objects with a handy 'writeln' method"""
18 def __init__(self, stream):
19 self.stream = stream
20
21 def __getattr__(self, attr):
22 if attr in ('stream', '__getstate__'):
23 raise AttributeError(attr)
24 return getattr(self.stream, attr)
25
26 def writeln(self, arg=None):
27 if arg:
28 self.write(arg)
29 self.write('\n') # text-mode streams translate to \r\n if needed
30
31
32 class TextTestResult(result.TestResult):
33 """A test result class that can print formatted text results to a stream.
34
35 Used by TextTestRunner.
36 """
37 separator1 = '=' * 70
38 separator2 = '-' * 70
39
40 def __init__(self, stream, descriptions, verbosity, *, durations=None):
41 """Construct a TextTestResult. Subclasses should accept **kwargs
42 to ensure compatibility as the interface changes."""
43 super(TextTestResult, self).__init__(stream, descriptions, verbosity)
44 self.stream = stream
45 self.showAll = verbosity > 1
46 self.dots = verbosity == 1
47 self.descriptions = descriptions
48 self._theme = get_theme(tty_file=stream).unittest
49 self._newline = True
50 self.durations = durations
51
52 def getDescription(self, test):
53 doc_first_line = test.shortDescription()
54 if self.descriptions and doc_first_line:
55 return '\n'.join((str(test), doc_first_line))
56 else:
57 return str(test)
58
59 def startTest(self, test):
60 super(TextTestResult, self).startTest(test)
61 if self.showAll:
62 self.stream.write(self.getDescription(test))
63 self.stream.write(" ... ")
64 self.stream.flush()
65 self._newline = False
66
67 def _write_status(self, test, status):
68 is_subtest = isinstance(test, _SubTest)
69 if is_subtest or self._newline:
70 if not self._newline:
71 self.stream.writeln()
72 if is_subtest:
73 self.stream.write(" ")
74 self.stream.write(self.getDescription(test))
75 self.stream.write(" ... ")
76 self.stream.writeln(status)
77 self.stream.flush()
78 self._newline = True
79
80 def addSubTest(self, test, subtest, err):
81 if err is not None:
82 t = self._theme
83 if self.showAll:
84 if issubclass(err[0], subtest.failureException):
85 self._write_status(subtest, f"{t.fail}FAIL{t.reset}")
86 else:
87 self._write_status(subtest, f"{t.fail}ERROR{t.reset}")
88 elif self.dots:
89 if issubclass(err[0], subtest.failureException):
90 self.stream.write(f"{t.fail}F{t.reset}")
91 else:
92 self.stream.write(f"{t.fail}E{t.reset}")
93 self.stream.flush()
94 super(TextTestResult, self).addSubTest(test, subtest, err)
95
96 def addSuccess(self, test):
97 super(TextTestResult, self).addSuccess(test)
98 t = self._theme
99 if self.showAll:
100 self._write_status(test, f"{t.passed}ok{t.reset}")
101 elif self.dots:
102 self.stream.write(f"{t.passed}.{t.reset}")
103 self.stream.flush()
104
105 def addError(self, test, err):
106 super(TextTestResult, self).addError(test, err)
107 t = self._theme
108 if self.showAll:
109 self._write_status(test, f"{t.fail}ERROR{t.reset}")
110 elif self.dots:
111 self.stream.write(f"{t.fail}E{t.reset}")
112 self.stream.flush()
113
114 def addFailure(self, test, err):
115 super(TextTestResult, self).addFailure(test, err)
116 t = self._theme
117 if self.showAll:
118 self._write_status(test, f"{t.fail}FAIL{t.reset}")
119 elif self.dots:
120 self.stream.write(f"{t.fail}F{t.reset}")
121 self.stream.flush()
122
123 def addSkip(self, test, reason):
124 super(TextTestResult, self).addSkip(test, reason)
125 t = self._theme
126 if self.showAll:
127 self._write_status(test, f"{t.warn}skipped{t.reset} {reason!r}")
128 elif self.dots:
129 self.stream.write(f"{t.warn}s{t.reset}")
130 self.stream.flush()
131
132 def addExpectedFailure(self, test, err):
133 super(TextTestResult, self).addExpectedFailure(test, err)
134 t = self._theme
135 if self.showAll:
136 self.stream.writeln(f"{t.warn}expected failure{t.reset}")
137 self.stream.flush()
138 elif self.dots:
139 self.stream.write(f"{t.warn}x{t.reset}")
140 self.stream.flush()
141
142 def addUnexpectedSuccess(self, test):
143 super(TextTestResult, self).addUnexpectedSuccess(test)
144 t = self._theme
145 if self.showAll:
146 self.stream.writeln(f"{t.fail}unexpected success{t.reset}")
147 self.stream.flush()
148 elif self.dots:
149 self.stream.write(f"{t.fail}u{t.reset}")
150 self.stream.flush()
151
152 def printErrors(self):
153 t = self._theme
154 if self.dots or self.showAll:
155 self.stream.writeln()
156 self.stream.flush()
157 self.printErrorList(f"{t.fail}ERROR{t.reset}", self.errors)
158 self.printErrorList(f"{t.fail}FAIL{t.reset}", self.failures)
159 unexpectedSuccesses = getattr(self, "unexpectedSuccesses", ())
160 if unexpectedSuccesses:
161 self.stream.writeln(self.separator1)
162 for test in unexpectedSuccesses:
163 self.stream.writeln(
164 f"{t.fail}UNEXPECTED SUCCESS{t.fail_info}: "
165 f"{self.getDescription(test)}{t.reset}"
166 )
167 self.stream.flush()
168
169 def printErrorList(self, flavour, errors):
170 t = self._theme
171 for test, err in errors:
172 self.stream.writeln(self.separator1)
173 self.stream.writeln(
174 f"{flavour}{t.fail_info}: {self.getDescription(test)}{t.reset}"
175 )
176 self.stream.writeln(self.separator2)
177 self.stream.writeln("%s" % err)
178 self.stream.flush()
179
180
181 class TextTestRunner(object):
182 """A test runner class that displays results in textual form.
183
184 It prints out the names of tests as they are run, errors as they
185 occur, and a summary of the results at the end of the test run.
186 """
187 resultclass = TextTestResult
188
189 def __init__(self, stream=None, descriptions=True, verbosity=1,
190 failfast=False, buffer=False, resultclass=None, warnings=None,
191 *, tb_locals=False, durations=None):
192 """Construct a TextTestRunner.
193
194 Subclasses should accept **kwargs to ensure compatibility as the
195 interface changes.
196 """
197 if stream is None:
198 stream = sys.stderr
199 self.stream = _WritelnDecorator(stream)
200 self.descriptions = descriptions
201 self.verbosity = verbosity
202 self.failfast = failfast
203 self.buffer = buffer
204 self.tb_locals = tb_locals
205 self.durations = durations
206 self.warnings = warnings
207 if resultclass is not None:
208 self.resultclass = resultclass
209
210 def _makeResult(self):
211 try:
212 return self.resultclass(self.stream, self.descriptions,
213 self.verbosity, durations=self.durations)
214 except TypeError:
215 # didn't accept the durations argument
216 return self.resultclass(self.stream, self.descriptions,
217 self.verbosity)
218
219 def _printDurations(self, result):
220 if not result.collectedDurations:
221 return
222 ls = sorted(result.collectedDurations, key=lambda x: x[1],
223 reverse=True)
224 if self.durations > 0:
225 ls = ls[:self.durations]
226 self.stream.writeln("Slowest test durations")
227 if hasattr(result, 'separator2'):
228 self.stream.writeln(result.separator2)
229 hidden = False
230 for test, elapsed in ls:
231 if self.verbosity < 2 and elapsed < 0.001:
232 hidden = True
233 continue
234 self.stream.writeln("%-10s %s" % ("%.3fs" % elapsed, test))
235 if hidden:
236 self.stream.writeln("\n(durations < 0.001s were hidden; "
237 "use -v to show these durations)")
238 else:
239 self.stream.writeln("")
240
241 def run(self, test):
242 "Run the given test case or test suite."
243 result = self._makeResult()
244 registerResult(result)
245 result.failfast = self.failfast
246 result.buffer = self.buffer
247 result.tb_locals = self.tb_locals
248 with warnings.catch_warnings():
249 if self.warnings:
250 # if self.warnings is set, use it to filter all the warnings
251 warnings.simplefilter(self.warnings)
252 start_time = time.perf_counter()
253 startTestRun = getattr(result, 'startTestRun', None)
254 if startTestRun is not None:
255 startTestRun()
256 try:
257 test(result)
258 finally:
259 stopTestRun = getattr(result, 'stopTestRun', None)
260 if stopTestRun is not None:
261 stopTestRun()
262 stop_time = time.perf_counter()
263 time_taken = stop_time - start_time
264 result.printErrors()
265 if self.durations is not None:
266 self._printDurations(result)
267
268 if hasattr(result, 'separator2'):
269 self.stream.writeln(result.separator2)
270
271 run = result.testsRun
272 self.stream.writeln("Ran %d test%s in %.3fs" %
273 (run, run != 1 and "s" or "", time_taken))
274 self.stream.writeln()
275
276 expected_fails = unexpected_successes = skipped = 0
277 try:
278 results = map(len, (result.expectedFailures,
279 result.unexpectedSuccesses,
280 result.skipped))
281 except AttributeError:
282 pass
283 else:
284 expected_fails, unexpected_successes, skipped = results
285
286 infos = []
287 t = get_theme(tty_file=self.stream).unittest
288
289 if not result.wasSuccessful():
290 self.stream.write(f"{t.fail_info}FAILED{t.reset}")
291 failed, errored = len(result.failures), len(result.errors)
292 if failed:
293 infos.append(f"{t.fail_info}failures={failed}{t.reset}")
294 if errored:
295 infos.append(f"{t.fail_info}errors={errored}{t.reset}")
296 elif run == 0 and not skipped:
297 self.stream.write(f"{t.warn}NO TESTS RAN{t.reset}")
298 else:
299 self.stream.write(f"{t.passed}OK{t.reset}")
300 if skipped:
301 infos.append(f"{t.warn}skipped={skipped}{t.reset}")
302 if expected_fails:
303 infos.append(f"{t.warn}expected failures={expected_fails}{t.reset}")
304 if unexpected_successes:
305 infos.append(
306 f"{t.fail}unexpected successes={unexpected_successes}{t.reset}"
307 )
308 if infos:
309 self.stream.writeln(" (%s)" % (", ".join(infos),))
310 else:
311 self.stream.write("\n")
312 self.stream.flush()
313 return result