# >>> logging.basicConfig(stream=HTMLTestRunner.stdout_redirector)
# >>>
+
class OutputRedirector(object):
- """ Wrapper to redirect stdout or stderr """
+ """Wrapper to redirect stdout or stderr"""
+
def __init__(self, fp):
self.fp = fp
def flush(self):
self.fp.flush()
+
stdout_redirector = OutputRedirector(sys.stdout)
stderr_redirector = OutputRedirector(sys.stderr)
-
# ----------------------------------------------------------------------
# Template
+
class Template_mixin(object):
"""
Define a HTML template for report customerization and generation.
"""
STATUS = {
- 0: 'pass',
- 1: 'fail',
- 2: 'error',
+ 0: "pass",
+ 1: "fail",
+ 2: "error",
}
- DEFAULT_TITLE = 'Unit Test Report'
- DEFAULT_DESCRIPTION = ''
+ DEFAULT_TITLE = "Unit Test Report"
+ DEFAULT_DESCRIPTION = ""
# ------------------------------------------------------------------------
# HTML Template
"""
# variables: (title, generator, stylesheet, heading, report, ending)
-
# ------------------------------------------------------------------------
# Stylesheet
#
</style>
"""
-
-
# ------------------------------------------------------------------------
# Heading
#
<p class='description'>%(description)s</p>
</div>
-""" # variables: (title, parameters, description)
+""" # variables: (title, parameters, description)
HEADING_ATTRIBUTE_TMPL = """<p class='attribute'><strong>%(name)s:</strong> %(value)s</p>
-""" # variables: (name, value)
-
-
+""" # variables: (name, value)
# ------------------------------------------------------------------------
# Report
<td> </td>
</tr>
</table>
-""" # variables: (test_list, count, Pass, fail, error)
+""" # variables: (test_list, count, Pass, fail, error)
REPORT_CLASS_TMPL = r"""
<tr class='%(style)s'>
<td>%(error)s</td>
<td><a href="javascript:showClassDetail('%(cid)s',%(count)s)">Detail</a></td>
</tr>
-""" # variables: (style, desc, count, Pass, fail, error, cid)
-
+""" # variables: (style, desc, count, Pass, fail, error, cid)
REPORT_TEST_WITH_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
</td>
</tr>
-""" # variables: (tid, Class, style, desc, status)
-
+""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_NO_OUTPUT_TMPL = r"""
<tr id='%(tid)s' class='%(Class)s'>
<td class='%(style)s'><div class='testcase'>%(desc)s</div></td>
<td colspan='5' align='center'>%(status)s</td>
</tr>
-""" # variables: (tid, Class, style, desc, status)
-
+""" # variables: (tid, Class, style, desc, status)
REPORT_TEST_OUTPUT_TMPL = r"""
%(id)s: %(output)s
-""" # variables: (id, output)
-
-
+""" # variables: (id, output)
# ------------------------------------------------------------------------
# ENDING
ENDING_TMPL = """<div id='ending'> </div>"""
+
# -------------------- The end of the Template class -------------------
TestResult = unittest.TestResult
+
class _TestResult(TestResult):
# note: _TestResult is a pure representation of results.
# It lacks the output and reporting ability compares to unittest._TextTestResult.
# )
self.result = []
-
def startTest(self, test):
TestResult.startTest(self, test)
# just one buffer for both stdout and stderr
sys.stdout = stdout_redirector
sys.stderr = stderr_redirector
-
def complete_output(self):
"""
Disconnect output redirection and return buffer.
self.stderr0 = None
return self.outputBuffer.getvalue()
-
def stopTest(self, test):
# Usually one of addSuccess, addError or addFailure would have been called.
# But there are some path in unittest that would bypass this.
# We must disconnect stdout in stopTest(), which is guaranteed to be called.
self.complete_output()
-
def addSuccess(self, test):
self.success_count += 1
TestResult.addSuccess(self, test)
output = self.complete_output()
- self.result.append((0, test, output, ''))
+ self.result.append((0, test, output, ""))
if self.verbosity > 1:
- sys.stderr.write('ok ')
+ sys.stderr.write("ok ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('.')
+ sys.stderr.write(".")
def addError(self, test, err):
self.error_count += 1
output = self.complete_output()
self.result.append((2, test, output, _exc_str))
if self.verbosity > 1:
- sys.stderr.write('E ')
+ sys.stderr.write("E ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('E')
+ sys.stderr.write("E")
def addFailure(self, test, err):
self.failure_count += 1
output = self.complete_output()
self.result.append((1, test, output, _exc_str))
if self.verbosity > 1:
- sys.stderr.write('F ')
+ sys.stderr.write("F ")
sys.stderr.write(str(test))
- sys.stderr.write('\n')
+ sys.stderr.write("\n")
else:
- sys.stderr.write('F')
+ sys.stderr.write("F")
class HTMLTestRunner(Template_mixin):
- """
- """
+ """ """
+
def __init__(self, stream=sys.stdout, verbosity=1, title=None, description=None):
self.stream = stream
self.verbosity = verbosity
self.startTime = datetime.datetime.now()
-
def run(self, test):
"Run the given test case or test suite."
result = _TestResult(self.verbosity)
test(result)
self.stopTime = datetime.datetime.now()
self.generateReport(test, result)
- print >>sys.stderr, '\nTime Elapsed: %s' % (self.stopTime-self.startTime)
+ print >>sys.stderr, "\nTime Elapsed: %s" % (self.stopTime - self.startTime)
return result
-
def sortResult(self, result_list):
# unittest does not seems to run in any particular order.
# Here at least we want to group them together by class.
rmap = {}
classes = []
- for n,t,o,e in result_list:
+ for n, t, o, e in result_list:
cls = t.__class__
if not cls in rmap:
rmap[cls] = []
classes.append(cls)
- rmap[cls].append((n,t,o,e))
+ rmap[cls].append((n, t, o, e))
r = [(cls, rmap[cls]) for cls in classes]
return r
-
def getReportAttributes(self, result):
"""
Return report attributes as a list of (name, value).
startTime = str(self.startTime)[:19]
duration = str(self.stopTime - self.startTime)
status = []
- if result.success_count: status.append('Pass %s' % result.success_count)
- if result.failure_count: status.append('Failure %s' % result.failure_count)
- if result.error_count: status.append('Error %s' % result.error_count )
+ if result.success_count:
+ status.append("Pass %s" % result.success_count)
+ if result.failure_count:
+ status.append("Failure %s" % result.failure_count)
+ if result.error_count:
+ status.append("Error %s" % result.error_count)
if status:
- status = ' '.join(status)
+ status = " ".join(status)
else:
- status = 'none'
+ status = "none"
return [
- ('Start Time', startTime),
- ('Duration', duration),
- ('Status', status),
+ ("Start Time", startTime),
+ ("Duration", duration),
+ ("Status", status),
]
-
def generateReport(self, test, result):
report_attrs = self.getReportAttributes(result)
- generator = 'HTMLTestRunner %s' % __version__
+ generator = "HTMLTestRunner %s" % __version__
stylesheet = self._generate_stylesheet()
heading = self._generate_heading(report_attrs)
report = self._generate_report(result)
ending = self._generate_ending()
output = self.HTML_TMPL % dict(
- title = saxutils.escape(self.title),
- generator = generator,
- stylesheet = stylesheet,
- heading = heading,
- report = report,
- ending = ending,
+ title=saxutils.escape(self.title),
+ generator=generator,
+ stylesheet=stylesheet,
+ heading=heading,
+ report=report,
+ ending=ending,
)
- self.stream.write(output.encode('utf8'))
-
+ self.stream.write(output.encode("utf8"))
def _generate_stylesheet(self):
return self.STYLESHEET_TMPL
-
def _generate_heading(self, report_attrs):
a_lines = []
for name, value in report_attrs:
line = self.HEADING_ATTRIBUTE_TMPL % dict(
- name = saxutils.escape(name),
- value = saxutils.escape(value),
- )
+ name=saxutils.escape(name),
+ value=saxutils.escape(value),
+ )
a_lines.append(line)
heading = self.HEADING_TMPL % dict(
- title = saxutils.escape(self.title),
- parameters = ''.join(a_lines),
- description = saxutils.escape(self.description),
+ title=saxutils.escape(self.title),
+ parameters="".join(a_lines),
+ description=saxutils.escape(self.description),
)
return heading
-
def _generate_report(self, result):
rows = []
sortedResult = self.sortResult(result.result)
for cid, (cls, cls_results) in enumerate(sortedResult):
# subtotal for a class
np = nf = ne = 0
- for n,t,o,e in cls_results:
- if n == 0: np += 1
- elif n == 1: nf += 1
- else: ne += 1
+ for n, t, o, e in cls_results:
+ if n == 0:
+ np += 1
+ elif n == 1:
+ nf += 1
+ else:
+ ne += 1
# format class description
if cls.__module__ == "__main__":
else:
name = "%s.%s" % (cls.__module__, cls.__name__)
doc = cls.__doc__ and cls.__doc__.split("\n")[0] or ""
- desc = doc and '%s: %s' % (name, doc) or name
+ desc = doc and "%s: %s" % (name, doc) or name
row = self.REPORT_CLASS_TMPL % dict(
- style = ne > 0 and 'errorClass' or nf > 0 and 'failClass' or 'passClass',
- desc = desc,
- count = np+nf+ne,
- Pass = np,
- fail = nf,
- error = ne,
- cid = 'c%s' % (cid+1),
+ style=ne > 0 and "errorClass" or nf > 0 and "failClass" or "passClass",
+ desc=desc,
+ count=np + nf + ne,
+ Pass=np,
+ fail=nf,
+ error=ne,
+ cid="c%s" % (cid + 1),
)
rows.append(row)
- for tid, (n,t,o,e) in enumerate(cls_results):
+ for tid, (n, t, o, e) in enumerate(cls_results):
self._generate_report_test(rows, cid, tid, n, t, o, e)
report = self.REPORT_TMPL % dict(
- test_list = ''.join(rows),
- count = str(result.success_count+result.failure_count+result.error_count),
- Pass = str(result.success_count),
- fail = str(result.failure_count),
- error = str(result.error_count),
+ test_list="".join(rows),
+ count=str(result.success_count + result.failure_count + result.error_count),
+ Pass=str(result.success_count),
+ fail=str(result.failure_count),
+ error=str(result.error_count),
)
return report
-
def _generate_report_test(self, rows, cid, tid, n, t, o, e):
# e.g. 'pt1.1', 'ft1.1', etc
has_output = bool(o or e)
- tid = (n == 0 and 'p' or 'f') + 't%s.%s' % (cid+1,tid+1)
- name = t.id().split('.')[-1]
+ tid = (n == 0 and "p" or "f") + "t%s.%s" % (cid + 1, tid + 1)
+ name = t.id().split(".")[-1]
doc = t.shortDescription() or ""
- desc = doc and ('%s: %s' % (name, doc)) or name
- tmpl = has_output and self.REPORT_TEST_WITH_OUTPUT_TMPL or self.REPORT_TEST_NO_OUTPUT_TMPL
+ desc = doc and ("%s: %s" % (name, doc)) or name
+ tmpl = (
+ has_output
+ and self.REPORT_TEST_WITH_OUTPUT_TMPL
+ or self.REPORT_TEST_NO_OUTPUT_TMPL
+ )
# o and e should be byte string because they are collected from stdout and stderr?
- if isinstance(o,str):
+ if isinstance(o, str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# uo = unicode(o.encode('string_escape'))
- uo = o.decode('latin-1')
+ uo = o.decode("latin-1")
else:
uo = o
- if isinstance(e,str):
+ if isinstance(e, str):
# TODO: some problem with 'string_escape': it escape \n and mess up formating
# ue = unicode(e.encode('string_escape'))
- ue = e.decode('latin-1')
+ ue = e.decode("latin-1")
else:
ue = e
script = self.REPORT_TEST_OUTPUT_TMPL % dict(
- id = tid,
- output = saxutils.escape(uo+ue),
+ id=tid,
+ output=saxutils.escape(uo + ue),
)
row = tmpl % dict(
- tid = tid,
- Class = (n == 0 and 'hiddenRow' or 'none'),
- style = n == 2 and 'errorCase' or (n == 1 and 'failCase' or 'none'),
- desc = desc,
- script = script,
- status = self.STATUS[n],
+ tid=tid,
+ Class=(n == 0 and "hiddenRow" or "none"),
+ style=n == 2 and "errorCase" or (n == 1 and "failCase" or "none"),
+ desc=desc,
+ script=script,
+ status=self.STATUS[n],
)
rows.append(row)
if not has_output:
A variation of the unittest.TestProgram. Please refer to the base
class for command line parameters.
"""
+
def runTests(self):
# Pick HTMLTestRunner as the default test runner.
# base class's testRunner parameter is not useful because it means
self.testRunner = HTMLTestRunner(verbosity=self.verbosity)
unittest.TestProgram.runTests(self)
+
main = TestProgram
##############################################################################
