Unittest二次开发实战-01-定制TestResult类
前言
Unittest是Python自带的自动化测试框架，提供了基本的控制结构和模型概念。
由于Unittest功能较为基础，因此在实际框架实战中往往需要对其功能进行扩充。
比如：
- 生成HTML报告
- 多线程并发（并且报告不混乱）
- 自动重试出错用例
- 为用例提供tags标签和level等级
等，往往需要我们对Unittest框架进行二次开发和扩展，由于Unittest框架清晰的API，扩展和定制也非常方便。
Unittest各个模块的API课参考：Unittest官方文档翻译
unittest.TestResult类简介
TestResult类一般在TestRunner类中实例化，并穿梭于每个执行的测试套件和测试用例中用于记录结果。
TestResult对象常用的属性有：
- stream：用于输出测试信息的IO流，一般是终端或文本文件。
- descriptions：描述信息。
- verbosity：显示详细级别。
- buffer：默认为False，用例中的print信息立即输出，buffer为True时将用例中的print信息统一收集并集中输出。
- tb_locals: 在报错异常信息中显示用例中的局部变量（即tackback_locals）。
- failfast：默认为False, 用例失败后继续运行，为True时，任何一条用例失败时立即停止。
- _mirrorOutput：是否重定向输出流状态标志
unittest.TestResult类提供了以下几种方法：
- 运行开始/结束
- startTestRun： 执行开始时调用，参考unittest.TextTestRunner中的run方法。
- stopTestRun： 所有用例执行结束后调用
- startTest：单个用例执行开始时调用，参考unittest.TestCase类中的run方法。
- stopTest：单个用例执行结束后调用。
- 注册用例结果
- addSuccess：单个用例执行成功时调用，来注册结果，默认为空。
- addFailure：用例失败时在stopTest前调用。
- addError：用例异常时在stopTest前调用。
- addSkip：用例跳过时在stopTest前调用。
- addExpectedFailure：用例期望失败时在stopTest前调用。
- addUnexpectedSuccess：用例非期望成功时在stopTest前调用。
- 重定向和恢复系统输出流
- _setupStdout：重定向输出流，默认self.buffer为True时生效
- _restoreStdout：恢复系统输出流
用例失败Failure和用例异常Error的区别：
用例中的断言错误（期望结果和实际结果不一致）引发的AssertionError异常被视为用例失败，其他异常视为用例异常Error。
ExpectedFailure和UnexpectedSuccess: 期望失败指我们期望这条用例执行失败，即用例失败了才是符合预期的，而没有失败即UnexpectedSuccess，这是一种反向用例，如果失败了其实是通过，而成功了反而是失败。
TestResult类定制目标
- 在result中增加整体的运行开始时间start_at，持续时间duration和每条用例的开始时间，执行时间
- 存储用例中的print信息及异常信息，以供生成HTML使用
- 为已知异常提供失败原因
- 提供结构化和可序列化的summary和详情数据
- 探测每个用例code，以为审视用例代码提供方便
- 增加运行平台platform信息和运行时的环境变量信息
- 将print信息改为使用log记录，增加日志时间，方便追溯。
- 提供用例的更多的信息，如tags，level， id， 描述等信息。
实现步骤
测试结果summary格式规划
测试结果result类提供一个summary属性，格式如下（参考了httprunner的summary格式）：
name: result结果名称
success: 整个测试结果是否成功
stat: # 结果统计信息
testsRun: 总运行数
successes: 成功数
failures: 失败数
errors: 异常数
skipped: 跳过的用例数
expectedFailures: 期望失败数
unexpectedSuccesses: 非期望成功数
time:
start_at: 整个测试开始时间(时间戳)
end_at: 增高测试结束时间(时间戳)
duration: 整个测试执行耗时(秒)
platform:
platform: 执行平台信息
system: 执行操作系统信息
python_version: Python版本信息
# env: 环境变量信息（信息中可能包含账号等敏感信息）
details: # 用例结果详情
- ... # 单个用例结果
单个用例结果格式规划
# 执行前可获取的信息
name: 用例名称或用例方法名
id: 用例完整路径(模块-类-用例方法名)
decritpion: 用例描述(用例方法docstring第一行)
doc: 用例方法完整docstring
module_name: 用例模块名
class_name: 用例类名
class_id: 用例类路径(模块-类)
class_doc: 用例类docstring描述
tags: 用例标签
level: 用例等级
code: 用例代码
# 执行后可获取的信息
time:
start_at: 用例执行开始时间
end_at: 用例结束时间
duration: 用例执行持续时间
status: 用例执行状态success/fail/error/skipped/xfail/xpass
output: 用例中的print输出信息
exc_info: 用例异常追溯信息
reason: 用例跳过,失败,出错的原因
读者也可以根据自己的需要添加其他额外的信息，如timeout用例超时时间配置，order用例执行顺序，images用例中的截图，link用例中的链接等信息。
以上的tags和level通过在用例方法的docstring中注入"tag:smoke"及"level:1"等样式为用例添加标签和等级，然后配合定制的loader用例加载器去收集指定标签或等级的用例，下节会详细讲解。
用例tags和level的实现
每个框架都会有自己约定格式，这里我采用在docstring注入特定格式描述的方式为用例添加tags和level信息，用例格式如下。
import unittest
class TestDemo(unittest.TestCase):
def test_a(self):
"""测试a
tag:smoke
tag:demo
level:1
"""
print('测试a')
对于每个用例对象，可以使用test._testMethodDoc来获取其完整的docstring字符串，然后通过正则匹配来匹配出用例的tags列表和level等级，实现方法如下。
import re
TAG_PARTTEN = 'tag:(\w+)'
LEVEL_PARTTEN = 'level:(\d+)'
def get_case_tags(case: unittest.TestCase) -> list:
"""从用例方法的docstring中匹配出指定格式的tags"""
case_tags = None
case_doc = case._testMethodDoc
if case_doc and 'tag' in case_doc:
pattern = re.compile(TAG_PARTTEN)
case_tags = re.findall(pattern, case_doc)
return case_tags
def get_case_level(case: unittest.TestCase):
"""从用例方法的docstring中匹配出指定格式的level"""
case_doc = case._testMethodDoc
case_level = None # todo 默认level
if case_doc:
pattern = re.compile(LEVEL_PARTTEN)
levels = re.findall(pattern, case_doc)
if levels:
case_level = levels[0]
try:
case_level = int(case_level)
except:
raise ValueError(f'用例中level设置：{case_level} 应为整数格式')
return case_level
根据测试方法对象获取用例代码
def inspect_code(test):
test_method = getattr(test.__class__, test._testMethodName)
try:
code = inspect.getsource(test_method)
except Exception as ex:
log.exception(ex)
code = ''
return code
单个用例结果类的实现
由于单个用例结果信息较多，我们可以在整个TestResult类中使用一个嵌套字典格式存储，也可以单独定制一个用例结果类，参考如下。
class TestCaseResult(object):
"""用例测试结果"""
def __init__(self, test: unittest.case.TestCase, name=None):
self.test = test # 测试用例对象
self.name = name or test._testMethodName # 支持传入用例别名，unittest.TestCase自带属性方法
self.id = test.id() # 用例完整路径，unittest.TestCase自带方法
self.description = test.shortDescription() # 用例简要描述，unittest.TestCase自带方法
self.doc = test._testMethodDoc # 用例docstring，，unittest.TestCase自带属性方法
self.module_name = test.__module__ # 用例所在模块名
self.class_name = test.__class__.__name__ # 用例所在类名
self.class_id = f'{test.__module__}.{test.__class__.__name__}' # 用例所在类完整路径
self.class_doc = test.__class__.__doc__ # 用例所在类docstring描述
self.tags = get_case_tags(test) # 获取用例tags
self.level = get_case_level(test) # 获取用例level等级
self.code = inspect_code(test) # 获取用例源代码
# 用例执后更新的信息
self.start_at = None # 用例开始时间
self.end_at = None # 用例结束时间
self.duration = None # 用例执行持续时间
self.status = None # 用例测试状态
self.output = None # 用例内的print信息
self.exc_info = None # 用例异常信息
self.reason = None # 跳过,失败,出错原因
@property
def data(self): # 组合字典格式的用例结果数据
data = dict(
name=self.name,
id=self.id,
description=self.description,
status=self.status,
tags=self.tags,
level=self.level,
time=dict( # 聚合时间信息
start_at=self.start_at,
end_at=self.end_at,
duration=self.duration
),
class_name=self.class_name,
class_doc=self.class_doc,
module_name=self.module_name,
code=self.code,
output=self.output,
exc_info=self.exc_info,
reason=self.reason,
)
return data
TestResult属性及初始化方法
根据上面对测试结果summary格式的规划，我们继承unittest.TestResult类来定制我们的测试结果类
import unittest
class TestResult(unittest.TestResult):
"""定制的测试结果类,补充用例运行时间等更多的执行信息"""
def __init__(self,stream=None,descriptions=None,verbosity=None):
super().__init__(stream, descriptions, verbosity) # 调用父类方法，继承父类的初始化属性，然后再进行扩充
# 对父类的默认熟悉做部分修改
self.testcase_results = [] # 所有用例测试结果对象（TestCaseResult对象）列表
self.successes = [] # 成功用例对象列表，万一用得着呢
self.verbosity = verbosity or 1 # 设置默认verbosity为1
self.buffer = True # 在本定制方法中强制使用self.buffer=True，缓存用例输出
self.name = None # 提供通过修改result对象的name属性为结果提供名称描述
self.start_at = None
self.end_at = None
self.duration = None
# 由于继承的父类属性中存在failures、errors等属性（存放失败和异常的用例列表），此处加以区分
self.successes_count = 0 # 成功用例数
self.failures_count = 0 # 失败用例数
self.errors_count = 0 # 异常用例数
self.skipped_count = 0 # 跳过用例数
self.expectedFailures_count = 0 # 期望失败用例数
self.unexpectedSuccesses_count = 0 # 非期望成功用例数
self.know_exceptions = {} # 已知异常字典，用于通过异常名来映射失败原因，如
# self.know_exceptions = {'requests.exceptions.ConnectionError': '请求连接异常'}
@property
def summary(self):
"""组装结果概要, details分按运行顺序和按类组织两种结构"""
data = dict(
name=self.name,
success=self.wasSuccessful(), # 用例是否成功，父类unittest.TestResult自带方法
stat=dict(
testsRun=self.testsRun,
successes=self.successes_count,
failures=self.failures_count,
errors=self.errors_count,
skipped=self.skipped_count,
expectedFailures=self.expectedFailures_count,
unexpectedSuccesses=self.unexpectedSuccesses_count,
),
time=dict(
start_at=self.start_at,
end_at=self.end_at,
duration=self.duration
),
platform=get_platform_info(),
details=[item.data for item in self.testcase_results] # 每个测试用例结果对象转为其字典格式的数据
)
return data
测试开始和测试结束
使用log信息代替原来的print输出到stream流，这里使用的是笔者发布的开源包logz，安装方法为：
pip install logz
logz非常方便配置和使用，支持方便的配置，单例，DayRoting，准确的调用追溯以及log到Email等，详细使用方法可参考：https://github.com/hanzhichao/logz。
TestResult类中的verbosity属性用于控制输出信息的详细等级，unittest.TextTestResult分为0，1，2三级，作者这里也采用3级模式，逻辑稍有不同，这里设计的逻辑如下。
- verbosity>1时：输出整个执行开始和结束信息，每个用例除自身print输出外，打印两条开始和结束两条日志，分别显示用例名称描述+执行时间和执行结果+持续时间。
- verbosity为1时：不输出整体开始和结束信息，只每天用例输出用例方法名和执行状态一行日志。
- verbosity为0时：不输出任何信息，包括错误信息。
以下为对父类执行开始和执行结束方法的重写。
import time
from logz import log # 需要安装logz
def time_to_string(timestamp: float) -> str:
"""时间戳转时间字符串，便于日志中更易读""
time_array = time.localtime(timestamp)
time_str = time.strftime("%Y-%m-%d %H:%M:%S", time_array)
return time_str
class TestResut(unittest.TestResult):
...
def startTestRun(self):
"""整个执行开始"""
self.start_at = time.time() # 整个执行的开始时间
if self.verbosity > 1:
self._log(f'===== 测试开始, 开始时间: {time_to_string(self.start_at)} =====')
def stopTestRun(self):
"""整个执行结束"""
self.end_at = time.time() # 整个执行的结束时间
self.duration = self.end_at - self.start_at # 整个执行的持续
self.success = self.wasSuccessful() # 整个执行是否成功
if self.verbosity > 1:
self._log(f'===== 测试结束, 持续时间: {self.duration}秒 =====')
由于父类中的startTestRun和stopTestRun没有任何内容，此处不需要再调用父类的方法。
原始的unittest.TextTestRunner中对整个执行时间的统计是在result对象外的，此处集成到result对象中，已使result的结果信息更完整。
用例开始和用例结束
捕获用例输出信息，在用例中常常会有print信息或出错信息，这里面的信息是直接写到系统标准输出stdout和stderr中的。要捕获并记录这些信息的话，我们需要再执行用例的过程中（从startTest到stopTest）将系统stdout和stderr临时重定向到我们的io流变量中，然后通过get_value()获取其中的字符串。
可喜的是，父类unittest.TestResult中便提供了重定向和恢复输出的参考方法，我们稍微改动即可。
- 重写恢复输出流方法
由于startTest父类中自动调用_setupOutput方法，并且强制self.buffer为True，因此会自动重定向信息流，无需重写。
这里去掉了对原始输出流的信息输出，改为return字符串，之后再使用log输出。
def _restoreStdout(self):
"""重写父类的_restoreStdout方法并返回output+error"""
if self.buffer:
output = error = ''
if self._mirrorOutput:
output = sys.stdout.getvalue()
error = sys.stderr.getvalue()
# 去掉了对原始输出流的信息输出
sys.stdout = self._original_stdout
sys.stderr = self._original_stderr
self._stdout_buffer.seek(0)
self._stdout_buffer.truncate()
self._stderr_buffer.seek(0)
self._stderr_buffer.truncate()
return output + error or None # 改为return字符串，之后再log输出
- 用例开始和结束方法
def startTest(self, test: unittest.case.TestCase):
"""单个用例执行开始"""
super().startTest(test) # 调用父类方法
test.result = TestCaseResult(test) # 实例化用例结果对象来记录用例结果，并绑定用例的result属性
self.testcase_results.append(test.result) # 另外添加到所有的结果列表一份
test.result.start_at = time.time() # 记录用例开始时间
if self.verbosity > 1:
self._log(f'执行用例: {test.result.name}: {test.result.description}, 开始时间: {time_to_string(test.result.start_at)}')
def stopTest(self, test: unittest.case.TestCase) -> None:
"""单个用例结束"""
test.result.end_at = time.time() # 记录用例结束时间
test.result.duration = test.result.end_at - test.result.start_at # 记录用例持续时间
# 由于output要从_restoreStdout获取，手动加入父类恢复输出流的方法
test.result.output = self._restoreStdout()
self._mirrorOutput = False # 是否重定向输出流标志
用例结果注册
def addSuccess(self, test):
"""重写父类方法, 单个用例成功时在stopTest前调用"""
test.result.status = TestStatus.SUCCESS
self.successes.append(test)
self.successes_count += 1
super().addSuccess(test)
@failfast
def addFailure(self, test, err):
"""重写父类方法, 用例失败时在stopTest前调用"""
test.result.status = TestStatus.FAIL
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.failures_count += 1
super().addFailure(test, err)
@failfast
def addError(self, test, err):
"""重写父类方法, 用例异常时在stopTest前调用"""
test.result.status = TestStatus.ERROR
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.errors_count += 1
super().addError(test, err)
def addSkip(self, test, reason):
"""重写父类方法, 用例跳过时在stopTest前调用"""
test.result.status = TestStatus.SKIPPED
test.result.reason = reason
self.skipped_count += 1
super().addSkip(test, reason)
def addExpectedFailure(self, test, err):
"""重写父类方法, 用例期望失败时在stopTest前调用"""
test.result.status = TestStatus.XFAIL
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.expectedFailures_count += 1
super().addExpectedFailure(test, err)
@failfast
def addUnexpectedSuccess(self, test):
"""重写父类方法, 用例非期望成功时在stopTest前调用"""
test.result.status = TestStatus.XPASS
self.expectedFailures_count += 1
super().addUnexpectedSuccess(test)
测试本TestResult类方法
if __name__ == '__main__':
import unittest
class TestDemo(unittest.TestCase):
def test_a(self): # 可以添加更多的用例进行测试
"""测试a
tag:smoke
tag:demo
level:1
"""
print('测试a')
suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestDemo)
runner = unittest.TextTestRunner(resultclass=TestResult) # 使用定制的TestResult类
result = runner.run(suite)
print(result.summary) # 输出result的字典格式数据，建议使用pprint输出，需要安装pprint
注：由于和作者本人自己使用的TestResult类有所精简和改动，尚未进行更多的测试，如有问题欢迎留言指正。
其他函数和方法
- 用例状态列
为了方便修改状态名称，（如改成中文），这里使用用例状态类。
class TestStatus(object):
SUCCESS = 'success'
FAIL = 'fail'
ERROR = 'error'
SKIPPED = 'skipped'
XFAIL = 'xfail'
XPASS = 'xpass'
- 获取平台信息
import os
def get_platform_info():
"""获取执行平台信息"""
return {
"platform": platform.platform(),
"system": platform.system(),
"python_version": platform.python_version(),
# "env": dict(os.environ),
}
- 从异常中提取异常信息方法
def _exc_info_to_string(self, err, test):
"""重写父类的转换异常方法, 去掉buffer的输出"""
exctype, value, tb = err
while tb and self._is_relevant_tb_level(tb):
tb = tb.tb_next
if exctype is test.failureException:
# Skip assert*() traceback levels
length = self._count_relevant_tb_levels(tb)
else:
length = None
tb_e = traceback.TracebackException(
exctype, value, tb, limit=length, capture_locals=self.tb_locals)
msgLines = list(tb_e.format())
return ''.join(msgLines)
- 从异常和已知异常中提取失败原因的方法
def _get_exc_msg(self, err):
exctype, value, tb = err
exc_msg = str(value)
exc_full_path = f'{exctype.__module__}.{exctype.__name__}'
if self.know_exceptions and isinstance(self.know_exceptions, dict):
exc_msg = self.know_exceptions.get(exc_full_path, exc_msg)
return exc_msg
点击查看完整代码
# 文件名: reult.py
import inspect
import platform
import sys
import time
import traceback
import unittest
import io
from unittest.result import failfast
import re
from logz import log
print = log.info
TAG_PARTTEN = 'tag:(\w+)'
LEVEL_PARTTEN = 'level:(\d+)'
def get_case_tags(case: unittest.TestCase) -> list:
"""从用例方法的docstring中匹配出指定格式的tags"""
case_tags = None
case_doc = case._testMethodDoc
if case_doc and 'tag' in case_doc:
pattern = re.compile(TAG_PARTTEN)
case_tags = re.findall(pattern, case_doc)
return case_tags
def get_case_level(case: unittest.TestCase):
"""从用例方法的docstring中匹配出指定格式的level"""
case_doc = case._testMethodDoc
case_level = None # todo 默认level
if case_doc:
pattern = re.compile(LEVEL_PARTTEN)
levels = re.findall(pattern, case_doc)
if levels:
case_level = levels[0]
try:
case_level = int(case_level)
except:
raise ValueError(f'用例中level设置：{case_level} 应为整数格式')
return case_level
class TestStatus(object):
SUCCESS = 'success'
FAIL = 'fail'
ERROR = 'error'
SKIPPED = 'skipped'
XFAIL = 'xfail'
XPASS = 'xpass'
def time_to_string(timestamp: float) -> str:
"""时间戳转时间字符串"""
time_array = time.localtime(timestamp)
time_str = time.strftime("%Y-%m-%d %H:%M:%S", time_array)
return time_str
def get_platform_info():
"""获取执行平台信息"""
return {
"platform": platform.platform(),
"system": platform.system(),
"python_version": platform.python_version(),
# "env": dict(os.environ), # 可能包含敏感信息
}
def inspect_code(test):
test_method = getattr(test.__class__, test._testMethodName)
try:
code = inspect.getsource(test_method)
except Exception as ex:
log.exception(ex)
code = ''
return code
class TestCaseResult(object):
"""用例测试结果"""
def __init__(self, test: unittest.case.TestCase, name=None):
self.test = test # 确保为测试用例
self.name = name or test._testMethodName
self.id = test.id()
self.description = test.shortDescription()
self.doc = test._testMethodDoc
self.module_name = test.__module__
self.class_name = test.__class__.__name__
self.class_id = f'{test.__module__}.{test.__class__.__name__}'
self.class_doc = test.__class__.__doc__
self.tags = get_case_tags(test)
self.level = get_case_level(test)
self.code = inspect_code(test)
self.start_at = None
self.end_at = None
self.duration = None
self.status = None
self.output = None
self.exc_info = None
self.reason = None # 跳过,失败,出错原因 todo
@property
def data(self):
data = dict(
name=self.name,
id=self.test.id(),
description=self.description,
status=self.status,
tags=self.tags,
level=self.level,
time=dict(
start_at=self.start_at,
end_at=self.end_at,
duration=self.duration
),
class_name=self.class_name,
class_doc=self.class_doc,
module_name=self.module_name,
code=self.code,
output=self.output,
exc_info=self.exc_info,
reason=self.reason,
)
return data
class TestResult(unittest.TestResult):
"""测试结果,补充整个过程的运行时间"""
def __init__(self,
stream=None,
descriptions=None,
verbosity=None,
):
super().__init__(stream, descriptions, verbosity)
self.successes = []
self.testcase_results = [] # 执行的用例结果列表
self.verbosity = verbosity or 1
self.buffer = True
self.know_exceptions = None
self.name = None
self.start_at = None
self.end_at = None
self.duration = None
self.successes_count = 0
self.failures_count = 0
self.errors_count = 0
self.skipped_count = 0
self.expectedFailures_count = 0
self.unexpectedSuccesses_count = 0
@property
def summary(self):
"""组装结果概要, details分按运行顺序和按类组织两种结构"""
data = dict(
name=self.name,
success=self.wasSuccessful(),
stat=dict(
testsRun=self.testsRun,
successes=self.successes_count,
failures=self.failures_count,
errors=self.errors_count,
skipped=self.skipped_count,
expectedFailures=self.expectedFailures_count,
unexpectedSuccesses=self.unexpectedSuccesses_count,
),
time=dict(
start_at=self.start_at,
end_at=self.end_at,
duration=self.duration
),
platform=get_platform_info(), # 环境信息的最后状态
details=[testcase_result.data for testcase_result in self.testcase_results]
)
return data
def _setupStdout(self):
if self.buffer:
if self._stderr_buffer is None:
self._stderr_buffer = io.StringIO()
self._stdout_buffer = io.StringIO()
sys.stdout = self._stdout_buffer
sys.stderr = self._stderr_buffer
def _restoreStdout(self):
"""重写父类的_restoreStdout方法并返回output+error"""
if self.buffer:
output = error = ''
if self._mirrorOutput:
output = sys.stdout.getvalue()
error = sys.stderr.getvalue()
sys.stdout = self._original_stdout
sys.stderr = self._original_stderr
self._stdout_buffer.seek(0)
self._stdout_buffer.truncate()
self._stderr_buffer.seek(0)
self._stderr_buffer.truncate()
return output + error or None
def _get_exc_msg(self, err):
exctype, value, tb = err
exc_msg = str(value)
exc_full_path = f'{exctype.__module__}.{exctype.__name__}'
if self.know_exceptions and isinstance(self.know_exceptions, dict):
exc_msg = self.know_exceptions.get(exc_full_path, exc_msg)
return exc_msg
def _exc_info_to_string(self, err, test):
"""重写父类的转换异常方法, 去掉buffer的输出"""
exctype, value, tb = err
while tb and self._is_relevant_tb_level(tb):
tb = tb.tb_next
if exctype is test.failureException:
# Skip assert*() traceback levels
length = self._count_relevant_tb_levels(tb)
else:
length = None
tb_e = traceback.TracebackException(
exctype, value, tb, limit=length, capture_locals=self.tb_locals)
msgLines = list(tb_e.format())
return ''.join(msgLines)
def startTestRun(self):
"""整个执行开始"""
self.start_at = time.time()
if self.verbosity > 1:
print(f'===== 测试开始, 开始时间: {time_to_string(self.start_at)} =====')
def stopTestRun(self):
"""整个执行结束"""
self.end_at = time.time()
self.duration = self.end_at - self.start_at
self.success = self.wasSuccessful()
if self.verbosity > 1:
print(f'===== 测试结束, 持续时间: {self.duration}秒 =====')
def startTest(self, test: unittest.case.TestCase):
"""单个用例执行开始"""
test.result = TestCaseResult(test)
self.testcase_results.append(test.result)
test.result.start_at = time.time()
super(TestResult, self).startTest(test)
if self.verbosity > 1:
print(f'执行用例: {test.result.name}: {test.result.description}, 开始时间: {time_to_string(test.result.start_at)}')
def stopTest(self, test: unittest.case.TestCase) -> None:
"""单个用例结束"""
test.result.end_at = time.time()
test.result.duration = test.result.end_at - test.result.start_at
test.result.output = self._restoreStdout()
self._mirrorOutput = False
if self.verbosity > 1:
print(f'结果: {test.result.status}, 持续时间: {test.result.duration}秒')
elif self.verbosity > 0:
print(f'{test.result.name} ... {test.result.status}')
if self.verbosity > 0:
if test.result.output:
print(f'{test.result.output.strip()}')
if test.result.exc_info:
log.exception(test.result.exc_info)
def addSuccess(self, test):
"""重写父类方法, 单个用例成功时在stopTest前调用"""
test.result.status = TestStatus.SUCCESS
self.successes.append(test)
self.successes_count += 1
super().addSuccess(test)
@failfast
def addFailure(self, test, err):
"""重写父类方法, 用例失败时在stopTest前调用"""
test.result.status = TestStatus.FAIL
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.failures_count += 1
super().addFailure(test, err)
@failfast
def addError(self, test, err):
"""重写父类方法, 用例异常时在stopTest前调用"""
test.result.status = TestStatus.ERROR
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.errors_count += 1
super().addError(test, err)
def addSkip(self, test, reason):
"""重写父类方法, 用例跳过时在stopTest前调用"""
test.result.status = TestStatus.SKIPPED
test.result.reason = reason
self.skipped_count += 1
super().addSkip(test, reason)
def addExpectedFailure(self, test, err):
"""重写父类方法, 用例期望失败时在stopTest前调用"""
test.result.status = TestStatus.XFAIL
test.result.exc_info = self._exc_info_to_string(err, test)
test.result.reason = self._get_exc_msg(err)
self.expectedFailures_count += 1
super().addExpectedFailure(test, err)
@failfast
def addUnexpectedSuccess(self, test):
"""重写父类方法, 用例非期望成功时在stopTest前调用"""
test.result.status = TestStatus.XPASS
self.expectedFailures_count += 1
super().addUnexpectedSuccess(test)
if __name__ == '__main__':
import unittest
class TestDemo(unittest.TestCase):
def test_a(self):
"""测试a
tag:smoke
tag:demo
level:1
"""
print('测试a')
suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestDemo)
runner = unittest.TextTestRunner(resultclass=TestResult) # 使用定制的TestResult类
result = runner.run(suite)
from pprint import pprint # 需要pip install pprint
print(result.summary)
在命令行中运行python result.py结果如下:
2020-09-21 22:57:45,418 INFO 测试a
2020-09-21 22:57:45,418 INFO test_a ... success
Ran 1 test in 0.006s
OK
{'details': [{'class_doc': None,
'class_name': 'TestDemo',
'code': ' def test_a(self):\n'
' """测试a\n'
' tag:smoke\n'
' tag:demo\n'
' level:1\n'
' """\n'
" print('测试a')\n",
'description': '测试a',
'exc_info': None,
'id': '__main__.TestDemo.test_a',
'level': 1,
'module_name': '__main__',
'name': 'test_a',
'output': None,
'reason': None,
'status': 'success',
'tags': ['smoke', 'demo'],
'time': {'duration': 0.0001838207244873047,
'end_at': 1600700265.418684,
'start_at': 1600700265.4185002}}],
'name': None,
'platform': {'platform': 'Darwin-19.6.0-x86_64-i386-64bit',
'python_version': '3.7.7',
'system': 'Darwin'},
'stat': {'errors': 0,
'expectedFailures': 0,
'failures': 0,
'skipped': 0,
'successes': 1,
'testsRun': 1,
'unexpectedSuccesses': 0},
'success': True,
'time': {'duration': 0.005582094192504883,
'end_at': 1600700265.418763,
'start_at': 1600700265.4131808}}
