Python 3.5单元测试运行时全局变量重置及单例隔离问题咨询

这确实是单例在测试场景下的典型坑——全局状态在测试用例/模块间共享，前面的测试会污染后面的测试环境，单个跑没问题但批量跑就崩。结合你的Python 3.5 + unittest场景，我给你几个优先级从高到低的解决方案：

1. 在测试生命周期中重置单例状态（最优解） #

最直接的办法是利用unittest的setUp()/tearDown()方法，在每个测试方法执行前后重置单例的状态，甚至销毁单例实例。

步骤1：给单例添加重置逻辑 #

如果你的单例代码可控，最好给它加一个重置状态的方法，或者暴露实例属性让测试可以重置：

class MainWrapperSingleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            # 初始化全局状态
            cls._instance.module_states = {}
            cls._instance.config = {}
        return cls._instance

    # 新增重置方法，把状态恢复到初始值
    def reset_state(self):
        self.module_states = {}
        self.config = {}

步骤2：在测试类中复用重置逻辑 #

写一个基础测试类，所有业务模块的测试类都继承它，避免重复代码：

import unittest
from your_app import MainWrapperSingleton

class BaseTestCase(unittest.TestCase):
    def tearDown(self):
        # 每个测试结束后重置单例状态
        MainWrapperSingleton().reset_state()
        # 如果需要彻底销毁单例（比如初始化逻辑复杂），可以直接清空实例
        # MainWrapperSingleton._instance = None

# 业务模块测试类继承这个基类
class TestSomeModule(BaseTestCase):
    def test_something(self):
        # 测试逻辑，不用担心之前的测试污染状态
        wrapper = MainWrapperSingleton()
        # ...

这个方案的优点是性能高、侵入性低，完全贴合unittest的执行流程。

2. 用unittest.mock隔离单例实例 #

如果单例代码不可修改（比如是第三方库或架构层面的代码），可以用unittest.mock的patch工具，在每个测试前强制重置单例的实例：

方式1：用装饰器给单个测试方法打补丁 #

from unittest.mock import patch
from your_app import MainWrapperSingleton

class TestSomeModule(unittest.TestCase):
    @patch.object(MainWrapperSingleton, '_instance', None)
    def test_something(self, mock_instance):
        # 这里创建的单例会是全新的实例
        wrapper = MainWrapperSingleton()
        # 测试逻辑...

方式2：在setUp中批量打补丁 #

class TestSomeModule(unittest.TestCase):
    def setUp(self):
        # 每次测试前重置单例的_instance属性
        self.patch_instance = patch.object(MainWrapperSingleton, '_instance', None)
        self.patch_instance.start()

    def tearDown(self):
        self.patch_instance.stop()

    def test_something(self):
        wrapper = MainWrapperSingleton()
        # ...

这个方案的好处是不用修改业务代码，完全在测试层解决问题，适合架构锁定的场景。

3. 让每个测试文件在独立进程中运行（兜底方案） #

如果上面两种方法都不适用（比如单例依赖的全局状态太复杂，无法重置），可以把每个测试文件放到独立进程中执行——因为进程间内存是隔离的，单例不会跨进程共享状态。

修改你的测试运行脚本，用multiprocessing来并行执行每个测试文件：

import multiprocessing
import unittest
import glob

def run_single_test_file(test_file):
    # 每个进程单独加载测试文件并运行
    loader = unittest.TestLoader()
    suite = loader.discover('tests', pattern=test_file)
    runner = unittest.TextTestRunner()
    runner.run(suite)

if __name__ == '__main__':
    # 获取所有测试文件
    test_files = [f.split('/')[-1] for f in glob.glob('tests/test_*.py')]
    # 用进程池运行测试
    with multiprocessing.Pool() as pool:
        pool.map(run_single_test_file, test_files)

这个方案的缺点是测试运行时间会变长，而且调试跨进程的问题会更麻烦，所以只建议作为最后手段。

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