testresult.py

'''Test runner and result class for the regression test suite.

'''

importfunctools
importio
importsys
importtime
importtraceback
importunittest

importxml.etree.ElementTreeasET

fromdatetimeimportdatetime

classRegressionTestResult(unittest.TextTestResult):
separator1='='*70+'\n'
separator2='-'*70+'\n'

def__init__(self, stream, descriptions, verbosity):
super().__init__(stream=stream, descriptions=descriptions, verbosity=0)
self.buffer=True
self.__suite=ET.Element('testsuite')
self.__suite.set('start', datetime.utcnow().isoformat(' '))

self.__e=None
self.__start_time=None
self.__results= []
self.__verbose=bool(verbosity)

@classmethod
def__getId(cls, test):
try:
test_id=test.id
exceptAttributeError:
returnstr(test)
try:
returntest_id()
exceptTypeError:
returnstr(test_id)
returnrepr(test)

defstartTest(self, test):
super().startTest(test)
self.__e=e=ET.SubElement(self.__suite, 'testcase')
self.__start_time=time.perf_counter()
ifself.__verbose:
self.stream.write(f'{self.getDescription(test)} ... ')
self.stream.flush()

def_add_result(self, test, capture=False, **args):
e=self.__e
self.__e=None
ifeisNone:
return
e.set('name', args.pop('name', self.__getId(test)))
e.set('status', args.pop('status', 'run'))
e.set('result', args.pop('result', 'completed'))
ifself.__start_time:
e.set('time', f'{time.perf_counter() -self.__start_time:0.6f}')

ifcapture:
ifself._stdout_bufferisnotNone:
stdout=self._stdout_buffer.getvalue().rstrip()
ET.SubElement(e, 'system-out').text=stdout
ifself._stderr_bufferisnotNone:
stderr=self._stderr_buffer.getvalue().rstrip()
ET.SubElement(e, 'system-err').text=stderr

fork, vinargs.items():
ifnotkornotv:
continue
e2=ET.SubElement(e, k)
ifhasattr(v, 'items'):
fork2, v2inv.items():
ifk2:
e2.set(k2, str(v2))
else:
e2.text=str(v2)
else:
e2.text=str(v)

def__write(self, c, word):
ifself.__verbose:
self.stream.write(f'{word}\n')

@classmethod
def__makeErrorDict(cls, err_type, err_value, err_tb):
ifisinstance(err_type, type):
iferr_type.__module__=='builtins':
typename=err_type.__name__
else:
typename=f'{err_type.__module__}.{err_type.__name__}'
else:
typename=repr(err_type)

msg=traceback.format_exception(err_type, err_value, None)
tb=traceback.format_exception(err_type, err_value, err_tb)

return {
'type': typename,
'message': ''.join(msg),
'': ''.join(tb),
 }

defaddError(self, test, err):
self._add_result(test, True, error=self.__makeErrorDict(*err))
super().addError(test, err)
self.__write('E', 'ERROR')

defaddExpectedFailure(self, test, err):
self._add_result(test, True, output=self.__makeErrorDict(*err))
super().addExpectedFailure(test, err)
self.__write('x', 'expected failure')

defaddFailure(self, test, err):
self._add_result(test, True, failure=self.__makeErrorDict(*err))
super().addFailure(test, err)
self.__write('F', 'FAIL')

defaddSkip(self, test, reason):
self._add_result(test, skipped=reason)
super().addSkip(test, reason)
self.__write('S', f'skipped {reason!r}')

defaddSuccess(self, test):
self._add_result(test)
super().addSuccess(test)
self.__write('.', 'ok')

defaddUnexpectedSuccess(self, test):
self._add_result(test, outcome='UNEXPECTED_SUCCESS')
super().addUnexpectedSuccess(test)
self.__write('u', 'unexpected success')

defprintErrors(self):
ifself.__verbose:
self.stream.write('\n')
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)

defprintErrorList(self, flavor, errors):
fortest, errinerrors:
self.stream.write(self.separator1)
self.stream.write(f'{flavor}: {self.getDescription(test)}\n')
self.stream.write(self.separator2)
self.stream.write('%s\n'%err)

defget_xml_element(self):
e=self.__suite
e.set('tests', str(self.testsRun))
e.set('errors', str(len(self.errors)))
e.set('failures', str(len(self.failures)))
returne

classQuietRegressionTestRunner:
def__init__(self, stream, buffer=False):
self.result=RegressionTestResult(stream, None, 0)
self.result.buffer=buffer

defrun(self, test):
test(self.result)
returnself.result

defget_test_runner_class(verbosity, buffer=False):
ifverbosity:
returnfunctools.partial(unittest.TextTestRunner,
resultclass=RegressionTestResult,
buffer=buffer,
verbosity=verbosity)
returnfunctools.partial(QuietRegressionTestRunner, buffer=buffer)

defget_test_runner(stream, verbosity, capture_output=False):
returnget_test_runner_class(verbosity, capture_output)(stream)

if__name__=='__main__':
classTestTests(unittest.TestCase):
deftest_pass(self):
pass

deftest_pass_slow(self):
time.sleep(1.0)

deftest_fail(self):
print('stdout', file=sys.stdout)
print('stderr', file=sys.stderr)
self.fail('failure message')

deftest_error(self):
print('stdout', file=sys.stdout)
print('stderr', file=sys.stderr)
raiseRuntimeError('error message')

suite=unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestTests))
stream=io.StringIO()
runner_cls=get_test_runner_class(sum(a=='-v'forainsys.argv))
runner=runner_cls(sys.stdout)
result=runner.run(suite)
print('Output:', stream.getvalue())
print('XML: ', end='')
forsinET.tostringlist(result.get_xml_element()):
print(s.decode(), end='')
print()