| 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 |