如何Mock类而非对象？及os.environ Mock失效问题咨询

我来分别解答你的两个问题：

如果你需要Mock整个类（而非类的某个实例），直接用unittest.mock.patch针对类本身即可。这样所有对该类的引用——不管是调用类方法、静态方法，还是创建实例——都会被替换成Mock对象。

举个实际例子，假设你有一个MyClass在my_module.py中：

# my_module.py
class MyClass:
    @classmethod
    def class_method(cls):
        return "original class method"
    
    def instance_method(self):
        return "original instance method"

要Mock这个类，测试代码可以这么写：

from unittest.mock import patch
from my_module import MyClass

def test_mock_entire_class():
    with patch('my_module.MyClass') as MockedClass:
        # 设置类方法的返回值
        MockedClass.class_method.return_value = "mocked class method"
        # 设置实例方法的返回值（通过return_value访问实例的方法）
        MockedClass.return_value.instance_method.return_value = "mocked instance method"
        
        # 调用类方法验证Mock效果
        assert MyClass.class_method() == "mocked class method"
        # 创建实例并调用方法
        instance = MyClass()
        assert instance.instance_method() == "mocked instance method"
        
        # 验证类被实例化过一次
        MockedClass.assert_called_once()

如果只需要Mock类的某个特定方法（而非整个类），可以直接patch目标方法：

def test_mock_class_method_only():
    with patch('my_module.MyClass.class_method') as mocked_method:
        mocked_method.return_value = "mocked"
        assert MyClass.class_method() == "mocked"

你的问题出在类属性初始化的时机上：A.VAR_A是在类定义阶段（也就是模块被导入时）就执行了os.environ.get("ABC")，而你的@patch.dict是在测试方法运行时才生效的——这时候VAR_A已经被赋值为None了，Mock自然没起作用。

这里有几种可行的解决方案：

方案1：延迟环境变量的读取（推荐） #

把VAR_A的读取逻辑移到方法内部，这样每次调用方法时才会读取os.environ，此时patch已经生效：

import os
from unittest import TestCase
from unittest.mock import patch

class A:
    @classmethod
    def foo(cls):
        return os.environ.get("ABC")  # 每次调用时才读取环境变量

@patch.dict(os.environ, {'ABC': 'abc'})
class Test_A(TestCase):
    def test_foo(self):
        self.assertEqual(A.foo(), 'abc')  # 现在能正常断言了

方案2：在测试中重新初始化类属性 #

如果必须保留VAR_A作为类属性，可以在测试方法里手动重新赋值，确保使用Mock后的环境变量：

import os
from unittest import TestCase
from unittest.mock import patch

class A:
    VAR_A = os.environ.get("ABC")
    
    @classmethod
    def foo(cls):
        return cls.VAR_A

@patch.dict(os.environ, {'ABC': 'abc'})
class Test_A(TestCase):
    def test_foo(self):
        # 重新初始化类属性，此时环境变量已被Mock
        A.VAR_A = os.environ.get("ABC")
        self.assertEqual(A.foo(), 'abc')

方案3：在导入类之前就Mock环境变量 #

确保在A类被导入（即类定义执行）之前，就把os.environMock好。可以把导入逻辑放到patch的上下文里：

import os
from unittest import TestCase
from unittest.mock import patch

class Test_A(TestCase):
    def setUp(self):
        # 在导入A之前先Mock环境变量
        with patch.dict(os.environ, {'ABC': 'abc'}):
            global A
            from my_module import A  # 假设A在my_module.py中

    def test_foo(self):
        self.assertEqual(A.foo(), 'abc')

这样就能保证类定义时读取的就是Mock后的环境变量了。

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