22. 用例依赖装饰器的实现思路和方法

news2025/5/23 15:16:36

22. 用例依赖装饰器的实现思路和方法

一、核心功能解析

1.1 实现目标

@depend(case='test_login')  # 当test_login失败时跳过当前测试
def test_order(self):
    pass

功能特性：

前置依赖检测
自动跳过失效用例
异常依赖关系校验
实时结果分析

二、代码逐行解析

2.1 自定义异常类

class DependencyError(Exception):
    def __init__(self, _type):
        self._type = _type  # 异常类型标识
    
    def __str__(self):
        # 根据类型返回不同错误信息
        if self._type == 0:
            return '必须指定依赖用例名称!' 
        if self._type == 1:
            return '不能依赖用例自身!'

异常触发场景：

异常类型	触发条件	示例
类型0	未指定依赖用例名称	`@depend()`
类型1	依赖自身用例	`@depend(case='test_self')`装饰test_self方法

2.2 装饰器主体结构

def depend(case=''):
    # 参数校验层
    if not case:
        raise DependencyError(0)  # 必须指定依赖用例
    
    _mark = []  # 存储失败/错误用例的容器

    def wrap_func(func):
        # 逻辑包装层
        @wraps(func)
        def inner_func(self):
            # 依赖校验层
            if case == func.__name__:
                raise DependencyError(1)
            
            # 结果收集逻辑
            _r = self._outcome.result
            _f, _e, _s = _r.failures, _r.errors, _r.skipped
            
            # 依赖检测逻辑
            if not (_f or _e or _s):
                func(self)  # 执行原始测试
            
            # 记录失败用例
            if _f: _mark.extend([fail[0] for fail in _f])
            if _e: _mark.extend([error[0] for error in _e])
            if _s: _mark.extend([skip[0] for skip in _s])
            
            # 动态跳过逻辑
            skip_condition = case in str(_mark)
            skip_reason = f'前置依赖用例 {case} 执行失败!'
            decorated_test = unittest.skipIf(skip_condition, skip_reason)(func)
            decorated_test(self)
            
        return inner_func
    return wrap_func

三、执行流程分析

3.1 正常执行流程

3.2 关键方法说明

代码段	功能说明	技术要点
`self._outcome.result`	获取测试结果对象	unittest内部机制
`_r.failures/errors/skipped`	收集失败/错误/跳过用例列表	测试结果数据结构解析
`unittest.skipIf()`	动态创建跳过装饰器	运行时条件判断

四、应用示例演示

4.1 测试类定义

class OrderTest(unittest.TestCase):
    def test_login(self):
        self.assertTrue(False)  # 模拟失败用例
    
    @depend(case='test_login')
    def test_create_order(self):
        print("正在创建订单")  # 应被跳过
    
    @depend(case='test_login')
    def test_pay_order(self):
        print("正在支付订单")  # 应被跳过
    
    @depend(case='test_check')
    def test_deliver(self):
        print("正在发货")  # 正常执行

4.2 执行结果

test_create_order (__main__.OrderTest) ... skipped '前置依赖用例 test_login 执行失败!'
test_deliver (__main__.OrderTest) ... ok
test_login (__main__.OrderTest) ... FAIL
test_pay_order (__main__.OrderTest) ... skipped '前置依赖用例 test_login 执行失败!'

======================================================================
FAIL: test_login (__main__.OrderTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test.py", line 8, in test_login
    self.assertTrue(False)
AssertionError: False is not true

----------------------------------------------------------------------
Ran 4 tests in 0.002s

FAILED (failures=1, skipped=2)

4.3 需注意的问题

例如测试用例数据如下：

import unittest
from .decorators import depend


class TestA(unittest.TestCase):

    def test_a(self):
        print(self.test_a.__name__)
        assert 1 == 1

    #@depend('test_a')
    def test_b(self):
        print(self.test_b.__name__)
        assert True

    @depend('test_d')
    def test_c(self):
        print(self.test_c.__name__)
        assert True


# @depend('test_a')
class TestB(unittest.TestCase):

    # @depend('test_a')
    def test_d(self):
        assert False


if __name__ == '__main__':
    unittest.main(verbosity=2)

当 test_c依赖test_d时，执行的结果是，test_c正常执行，这个@depend(‘test_d’)的装饰器并没有生效，所以在使用Unittest当中，要注意这个问题。

五、设计思想总结

5.1 关键技术点

技术点	解决的问题	实现方式
闭包嵌套	保持依赖用例名称的状态	三层函数嵌套结构
动态装饰	运行时决定是否跳过	unittest.skipIf动态应用
结果分析	检测前置用例状态	解析_result对象

5.2 工程实践建议

依赖命名规范：使用统一前缀如test_开头
依赖层级控制：避免形成环形依赖链
结果清理机制：在setUp中重置_mark状态
日志增强：添加详细的依赖关系日志

六、完整代码

"""
Python :3.13.3
Selenium: 4.31.0
"""

from functools import wraps
import unittest


class DependencyError(Exception):

    def __init__(self, _type):
        self._type = _type

    def __str__(self):
        if self._type == 0:
            return f'Dependency name of test is required!'
        if self._type == 1:
            return f'Dependency name of test can not the case self!'
        return None


def depend(case=''):
    if not case:
        raise DependencyError
    _mark = []

    def wrap_func(func):
        @wraps(func)
        def inner_func(self):
            if case == func.__name__:
                raise DependencyError(1)
            _r = self._outcome.result
            _f, _e, _s = _r.failures, _r.errors, _r.skipped

            if not (_f or _e or _s):
                func(self)

            if _f:
                _mark.extend([fail[0] for fail in _f])
            if _e:
                _mark.extend([error[0] for error in _e])
            if _s:
                _mark.extend([skip[0] for skip in _s])

            unittest.skipIf(
                case in str(_mark),
                f'The pre-depend case :{case} has failed! Skip the specified case!'
            )(func)(self)

        return inner_func
    return wrap_func

# @unittest.skipIf(case in str(_mark), '')
# def test(self):
#     ...
# @unittest.skipIf(case in str(_mark), '')(func)