blob: 93fc104a58619732d68e2c2e12cb32e3a922903c [file] [log] [blame]
"""Running tests"""
import sys
import time
import unittest
import progress
from unittest2 import result
try:
from unittest2.signals import registerResult
except ImportError:
def registerResult(_):
pass
__unittest = True
class _WritelnDecorator(object):
"""Used to decorate file-like objects with a handy 'writeln' method"""
def __init__(self, stream):
self.stream = stream
def __getattr__(self, attr):
if attr in ('stream', '__getstate__'):
raise AttributeError(attr)
return getattr(self.stream, attr)
def writeln(self, arg=None):
if arg:
self.write(arg)
self.write('\n') # text-mode streams translate to \r\n if needed
class TextTestResult(result.TestResult):
"""A test result class that can print formatted text results to a stream.
Used by TextTestRunner.
"""
separator1 = '=' * 70
separator2 = '-' * 70
def __init__(self, stream, descriptions, verbosity):
super(TextTestResult, self).__init__()
self.stream = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
self.descriptions = descriptions
self.progressbar = None
if self.dots:
self.stream.writeln(
".=success F=fail E=error s=skipped x=expected-fail u=unexpected-success")
self.stream.writeln("")
self.stream.flush()
def getDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
else:
return str(test)
def startTest(self, test):
super(TextTestResult, self).startTest(test)
if self.showAll:
self.stream.write(self.getDescription(test))
self.stream.write(" ... ")
self.stream.flush()
def newTestResult(self, test, result_short, result_long):
if self.showAll:
self.stream.writeln(result_long)
elif self.progressbar:
self.progressbar.__add__(1)
self.progressbar.add_event(result_short)
self.progressbar.show_progress()
elif self.dots:
self.stream.write(result_short)
self.stream.flush()
def addSuccess(self, test):
super(TextTestResult, self).addSuccess(test)
if self.progressbar:
self.newTestResult(test, "ok", "ok")
else:
self.newTestResult(test, ".", "ok")
def addError(self, test, err):
super(TextTestResult, self).addError(test, err)
self.newTestResult(test, "E", "ERROR")
def addFailure(self, test, err):
super(TextTestResult, self).addFailure(test, err)
self.newTestResult(test, "F", "FAILURE")
def addSkip(self, test, reason):
super(TextTestResult, self).addSkip(test, reason)
self.newTestResult(test, "s", "skipped %r" % (reason,))
def addExpectedFailure(self, test, err, bugnumber):
super(TextTestResult, self).addExpectedFailure(test, err, bugnumber)
self.newTestResult(test, "x", "expected failure")
def addUnexpectedSuccess(self, test, bugnumber):
super(TextTestResult, self).addUnexpectedSuccess(test, bugnumber)
self.newTestResult(test, "u", "unexpected success")
def printErrors(self):
if self.progressbar:
self.progressbar.complete()
self.progressbar.show_progress()
if self.dots or self.showAll:
self.stream.writeln()
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)
def printErrorList(self, flavour, errors):
for test, err in errors:
self.stream.writeln(self.separator1)
self.stream.writeln("%s: %s" %
(flavour, self.getDescription(test)))
self.stream.writeln(self.separator2)
self.stream.writeln("%s" % err)
def stopTestRun(self):
super(TextTestResult, self).stopTestRun()
self.printErrors()
class TextTestRunner(unittest.TextTestRunner):
"""A test runner class that displays results in textual form.
It prints out the names of tests as they are run, errors as they
occur, and a summary of the results at the end of the test run.
"""
resultclass = TextTestResult
def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1,
failfast=False, buffer=False, resultclass=None):
self.stream = _WritelnDecorator(stream)
self.descriptions = descriptions
self.verbosity = verbosity
self.failfast = failfast
self.buffer = buffer
if resultclass is not None:
self.resultclass = resultclass
def _makeResult(self):
return self.resultclass(self.stream, self.descriptions, self.verbosity)
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
result.failfast = self.failfast
result.buffer = self.buffer
registerResult(result)
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
else:
result.printErrors()
stopTime = time.time()
timeTaken = stopTime - startTime
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = passed = failed = errored = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped,
result.passes,
result.failures,
result.errors))
expectedFails, unexpectedSuccesses, skipped, passed, failed, errored = results
except AttributeError:
pass
infos = []
infos.append("%d passes" % passed)
infos.append("%d failures" % failed)
infos.append("%d errors" % errored)
infos.append("%d skipped" % skipped)
infos.append("%d expected failures" % expectedFails)
infos.append("%d unexpected successes" % unexpectedSuccesses)
self.stream.write("RESULT: ")
if not result.wasSuccessful():
self.stream.write("FAILED")
else:
self.stream.write("PASSED")
self.stream.writeln(" (%s)" % (", ".join(infos),))
return result