如何在Python中模块化存在依赖关系的单元测试？

问题背景 #

现有如下复合单元测试代码，它调用两个算法并进行验证，最后对比两者结果：

class MyTestCase(unittest.TestCase):
   def test_composite(self):
      # Test 1. Testing first algorithm
      result1 = algorithm1()
      assert len(result1) == 5, "Algorithm 1 failed"

      # Test 2. Testing second algorithm
      result2 = algorithm2()
      assert len(result2) == 5, "Algorithm 2 failed"

      # Test 3. Testing that algorithms are consistent
      assert result1 == result2, "Algorithm results are inconsistent"

需求如下：

• 前两项算法测试可独立运行，单个算法失败时能明确知晓另一个算法的测试状态
• 对比测试仅在前两项测试都通过时执行
• 每个算法的结果仅需计算一次
• 算法计算逻辑放在各自测试中，避免崩溃时无法定位问题（排除在__init__中提前计算的方案）

可选重构方案 #

方案1：拆分测试方法 + 实例属性缓存结果 #

将原有复合测试拆分为三个独立测试方法，通过实例属性缓存已成功计算的结果，确保每个算法仅计算一次，同时隔离异常。

import unittest

def algorithm1():
    return [1,2,3,4,5]

def algorithm2():
    return [1,2,3,4,5]

class MyTestCase(unittest.TestCase):
    def setUp(self):
        self._result1 = None
        self._result2 = None

    def test_algorithm1_length(self):
        if self._result1 is None:
            self._result1 = algorithm1()
        self.assertEqual(len(self._result1), 5, "Algorithm 1 failed length check")

    def test_algorithm2_length(self):
        if self._result2 is None:
            self._result2 = algorithm2()
        self.assertEqual(len(self._result2), 5, "Algorithm 2 failed length check")

    def test_algorithms_consistent(self):
        # 先确保算法1的结果有效，若未计算则执行验证逻辑
        if self._result1 is None:
            self._result1 = algorithm1()
            self.assertEqual(len(self._result1), 5, "Algorithm 1 failed length check")
        # 同理确保算法2的结果有效
        if self._result2 is None:
            self._result2 = algorithm2()
            self.assertEqual(len(self._result2), 5, "Algorithm 2 failed length check")
        # 只有前两项验证通过才会执行对比
        self.assertEqual(self._result1, self._result2, "Algorithm results are inconsistent")

说明：

• 三个测试方法独立运行，即使某一个算法测试失败，其他测试仍能正常执行
• 通过setUp初始化缓存属性，每个算法仅在首次需要时计算，后续直接复用缓存结果
• 对比测试会主动验证前两项的结果有效性，避免依赖测试执行顺序，确保只有前两项通过才会进入对比步骤

方案2：类属性记录状态 + skipIf装饰器控制执行 #

使用类属性记录前两个测试的通过状态，通过unittest.skipIf装饰器控制对比测试的执行，仅在前两项都通过时才运行。

import unittest

def algorithm1():
    return [1,2,3,4,5]

def algorithm2():
    return [1,2,3,4,5]

class MyTestCase(unittest.TestCase):
    _alg1_passed = False
    _alg2_passed = False
    _result1 = None
    _result2 = None

    def test_algorithm1_length(self):
        self.__class__._result1 = algorithm1()
        self.assertEqual(len(self.__class__._result1), 5, "Algorithm 1 failed length check")
        self.__class__._alg1_passed = True

    def test_algorithm2_length(self):
        self.__class__._result2 = algorithm2()
        self.assertEqual(len(self.__class__._result2), 5, "Algorithm 2 failed length check")
        self.__class__._alg2_passed = True

    @unittest.skipIf(not _alg1_passed or not _alg2_passed, "跳过一致性测试：一个或两个算法未通过前置验证")
    def test_algorithms_consistent(self):
        self.assertEqual(self.__class__._result1, self.__class__._result2, "Algorithm results are inconsistent")

说明：

• 类属性在所有测试实例间共享，确保结果和状态能跨测试方法传递
• skipIf装饰器会根据前置测试的状态自动跳过对比测试，无需手动验证
• 注意：unittest默认按方法名的ASCII顺序执行测试，需确保前置测试方法名在对比测试前（如当前命名顺序test_algorithm1_length → test_algorithm2_length → test_algorithms_consistent符合要求）

方案3：使用pytest依赖插件（需切换测试框架） #

若允许使用第三方测试框架pytest，可借助pytest-dependency插件实现更简洁的测试依赖管理，这也是最符合Python简洁风格的方案。

首先安装插件：

pip install pytest-dependency

测试代码：

import pytest

def algorithm1():
    return [1,2,3,4,5]

def algorithm2():
    return [1,2,3,4,5]

class TestAlgorithms:
    _result1 = None
    _result2 = None

    @pytest.mark.dependency()
    def test_algorithm1_length(self):
        self._result1 = algorithm1()
        assert len(self._result1) == 5, "Algorithm 1 failed length check"

    @pytest.mark.dependency()
    def test_algorithm2_length(self):
        self._result2 = algorithm2()
        assert len(self._result2) == 5, "Algorithm 2 failed length check"

    @pytest.mark.dependency(depends=["TestAlgorithms::test_algorithm1_length", "TestAlgorithms::test_algorithm2_length"])
    def test_algorithms_consistent(self):
        assert self._result1 == self._result2, "Algorithm results are inconsistent"

说明：

• pytest-dependency会自动管理测试依赖，只有前置测试全部通过，对比测试才会执行；否则对比测试会被标记为跳过
• 无需手动处理缓存和状态判断，插件会自动处理执行逻辑，代码更简洁易读
• 单个算法崩溃时，对应的测试会失败，另一个测试正常执行，对比测试被跳过，状态清晰

内容的提问来源于stack exchange，提问作者Aleksejs Fomins