Python单元测试中的Mocking机制：运行时替换对象的__call__与__getattribute__方法

Python 单元测试中的 Mocking 机制：运行时替换对象的 __call__ 与 __getattribute__ 方法

大家好，今天我们要深入探讨 Python 单元测试中非常重要的一个概念：Mocking 机制，特别是关注如何在运行时替换对象的 __call__ 和 __getattribute__ 方法。Mocking 是单元测试中隔离被测代码与其依赖项的关键技术，能够帮助我们编写更可靠、可控的测试。

为什么需要 Mocking？

在软件开发中，模块之间通常存在依赖关系。一个模块可能依赖于另一个模块提供的功能，或者依赖于外部系统（如数据库、API、文件系统等）。在进行单元测试时，我们希望只测试当前模块的功能，而不需要关心其依赖项的具体实现。如果依赖项出现问题，可能会影响到我们的测试结果，导致测试不稳定甚至失败。

这时，Mocking 就派上用场了。Mocking 允许我们创建一个假的依赖项，模拟其行为，从而隔离被测代码。通过 Mocking，我们可以：

• 隔离依赖项： 专注于测试单个模块的功能，避免依赖项的影响。
• 控制依赖项的行为： 模拟不同的返回值、异常或副作用，测试被测代码在各种情况下的表现。
• 提高测试速度： 避免访问外部系统，减少测试时间。
• 简化测试设置： 无需搭建复杂的测试环境，即可进行单元测试。

Python 中的 Mocking 工具：unittest.mock

Python 标准库中的 unittest.mock 模块提供了强大的 Mocking 功能。它允许我们创建 Mock 对象，并配置其行为，以模拟真实的依赖项。

Mock 对象的创建与基本使用

unittest.mock.Mock 类是 Mocking 的核心。我们可以通过创建 Mock 类的实例来创建一个 Mock 对象。

from unittest.mock import Mock

# 创建一个 Mock 对象
mock_obj = Mock()

# 设置 Mock 对象的返回值
mock_obj.return_value = 10

# 调用 Mock 对象
result = mock_obj()
print(result)  # 输出：10

# 设置 Mock 对象抛出异常
mock_obj.side_effect = ValueError("Something went wrong")

try:
    mock_obj()
except ValueError as e:
    print(e)  # 输出：Something went wrong

在这个例子中，我们首先创建了一个 Mock 对象 mock_obj。然后，我们使用 return_value 属性设置了 Mock 对象的返回值，并使用 side_effect 属性设置了 Mock 对象抛出的异常。当调用 mock_obj() 时，它会返回我们设置的值或抛出我们设置的异常。

Mock 对象的属性访问与方法调用

Mock 对象可以模拟任何 Python 对象，包括类、实例、函数等。我们可以通过属性访问和方法调用来配置 Mock 对象的行为。

from unittest.mock import Mock

# 创建一个 Mock 对象
mock_obj = Mock()

# 设置 Mock 对象的属性
mock_obj.name = "Test"
mock_obj.age = 20

# 访问 Mock 对象的属性
print(mock_obj.name)  # 输出：Test
print(mock_obj.age)  # 输出：20

# 设置 Mock 对象的方法
mock_obj.greet.return_value = "Hello, World!"

# 调用 Mock 对象的方法
result = mock_obj.greet()
print(result)  # 输出：Hello, World!

在这个例子中，我们设置了 mock_obj 对象的 name 和 age 属性，并设置了 greet 方法的返回值。注意，我们直接访问了 mock_obj.greet 属性，并设置了它的 return_value。这是因为 Mock 对象会自动创建不存在的属性和方法，并将它们也变成 Mock 对象。

运行时替换 __call__ 方法

__call__ 方法使得一个对象可以像函数一样被调用。在 Mocking 中，我们经常需要替换对象的 __call__ 方法，以模拟其行为。

from unittest.mock import Mock

class MyClass:
    def __call__(self):
        return "Original __call__"

# 创建 MyClass 的实例
obj = MyClass()

# 创建一个 Mock 对象
mock_call = Mock(return_value="Mocked __call__")

# 替换 obj 的 __call__ 方法
obj.__call__ = mock_call

# 调用 obj
result = obj()
print(result)  # 输出：Mocked __call__

# 检查 mock_call 是否被调用
mock_call.assert_called_once()

在这个例子中，我们首先定义了一个 MyClass 类，并实现了 __call__ 方法。然后，我们创建了一个 Mock 对象 mock_call，并将其 return_value 设置为 "Mocked call"。最后，我们将 obj 对象的 __call__ 方法替换为 mock_call。当调用 obj() 时，实际上调用的是 mock_call，因此返回的是 "Mocked call"。mock_call.assert_called_once() 断言 mock_call 被调用了一次。

运行时替换 __getattribute__ 方法

__getattribute__ 方法在每次访问对象的属性时都会被调用。通过替换 __getattribute__ 方法，我们可以拦截属性访问，并返回 Mock 对象或其他值。这在模拟复杂的对象结构时非常有用。

from unittest.mock import Mock

class MyClass:
    def __init__(self):
        self.name = "Original Name"
        self.age = 30

    def get_info(self):
        return f"Name: {self.name}, Age: {self.age}"

# 创建 MyClass 的实例
obj = MyClass()

# 创建一个 Mock 对象
mock_getattribute = Mock(side_effect=lambda name: Mock(return_value=f"Mocked {name}"))

# 替换 obj 的 __getattribute__ 方法
obj.__getattribute__ = mock_getattribute

# 访问 obj 的属性
print(obj.name)  # 输出：Mocked name
print(obj.age)   # 输出：Mocked age

# 访问 obj 的方法 (也会触发 __getattribute__)
print(obj.get_info()) #输出: Mocked get_info

# 检查 mock_getattribute 是否被调用
print(mock_getattribute.call_count) # 输出：3

在这个例子中，我们创建了一个 MyClass 类，并定义了 name 和 age 属性，以及 get_info 方法。然后，我们创建了一个 Mock 对象 mock_getattribute，并将其 side_effect 设置为一个 lambda 函数。这个 lambda 函数接收属性名作为参数，并返回一个新的 Mock 对象，其 return_value 为 "Mocked {属性名}"。最后，我们将 obj 对象的 __getattribute__ 方法替换为 mock_getattribute。

当访问 obj 的 name 和 age 属性时，实际上调用的是 mock_getattribute，它会返回一个新的 Mock 对象，其 return_value 分别为 "Mocked name" 和 "Mocked age"。访问 get_info 方法也会触发 __getattribute__ 方法，并返回 Mocked get_info。

使用 patch 装饰器进行 Mocking

unittest.mock.patch 装饰器提供了一种更方便的 Mocking 方式。它可以自动替换指定的对象或属性，并在测试结束后恢复原始状态。

from unittest.mock import patch
import unittest

class MyClass:
    def external_function(self):
        return "Original Function"

    def internal_function(self):
        return self.external_function()

class TestMyClass(unittest.TestCase):
    @patch('__main__.MyClass.external_function')
    def test_internal_function(self, mock_external_function):
        mock_external_function.return_value = "Mocked Function"
        obj = MyClass()
        result = obj.internal_function()
        self.assertEqual(result, "Mocked Function")
        mock_external_function.assert_called_once()

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

在这个例子中，我们使用了 patch 装饰器来替换 MyClass 类的 external_function 方法。patch 装饰器的第一个参数是要替换的对象或属性的名称，这里是 '__main__.MyClass.external_function'。第二个参数是可选的，用于指定一个 Mock 对象。如果没有指定，patch 装饰器会自动创建一个 Mock 对象，并将其作为测试方法的参数传递进来。

在测试方法中，我们可以通过 mock_external_function 对象来配置 external_function 的行为。我们将其 return_value 设置为 "Mocked Function"，然后调用 obj.internal_function() 方法。由于 external_function 方法已经被替换为 mock_external_function，因此 internal_function 方法实际上调用的是 mock_external_function，从而返回 "Mocked Function"。

patch 装饰器还可以在 with 语句中使用：

from unittest.mock import patch

class MyClass:
    def external_function(self):
        return "Original Function"

    def internal_function(self):
        return self.external_function()

with patch('__main__.MyClass.external_function') as mock_external_function:
    mock_external_function.return_value = "Mocked Function"
    obj = MyClass()
    result = obj.internal_function()
    print(result) # 输出：Mocked Function
    mock_external_function.assert_called_once()

# 在 with 语句结束后，external_function 会恢复到原始状态
obj = MyClass()
result = obj.external_function()
print(result) # 输出：Original Function

在这个例子中，patch 装饰器在 with 语句开始时替换 external_function 方法，并在 with 语句结束时恢复其原始状态。

MagicMock：更强大的 Mock 对象

unittest.mock.MagicMock 是 Mock 的一个子类，它提供了更多的 Magic Methods 的支持。Magic Methods 是 Python 中以双下划线开头和结尾的方法，如 __len__、__iter__、__add__ 等。MagicMock 能够自动处理这些 Magic Methods，使得 Mock 对象更像一个真实的 Python 对象。

from unittest.mock import MagicMock

# 创建一个 MagicMock 对象
mock_obj = MagicMock()

# 模拟 len() 函数
mock_obj.__len__.return_value = 5

# 调用 len() 函数
result = len(mock_obj)
print(result)  # 输出：5

# 模拟迭代
mock_obj.__iter__.return_value = iter([1, 2, 3])

# 迭代 Mock 对象
for item in mock_obj:
    print(item)  # 输出：1, 2, 3

# 模拟加法运算
mock_obj.__add__.return_value = "Added"

# 进行加法运算
result = mock_obj + "Another"
print(result)  # 输出：Added

在这个例子中，我们使用了 MagicMock 对象来模拟 len() 函数、迭代和加法运算。MagicMock 对象会自动处理这些 Magic Methods，使得我们可以像操作真实对象一样操作 Mock 对象。

Mocking 的一些高级技巧

• 使用 side_effect 模拟复杂的行为： side_effect 属性可以接受一个函数、一个可迭代对象或一个异常。如果 side_effect 是一个函数，每次调用 Mock 对象时都会执行该函数，并将函数的返回值作为 Mock 对象的返回值。如果 side_effect 是一个可迭代对象，每次调用 Mock 对象时都会返回可迭代对象的下一个值。如果 side_effect 是一个异常，每次调用 Mock 对象时都会抛出该异常。
• 使用 assert_called_with 和 assert_called_once_with 验证调用参数： assert_called_with 方法用于验证 Mock 对象是否被调用，并且调用时使用的参数是否与指定的参数相同。assert_called_once_with 方法用于验证 Mock 对象是否被调用了一次，并且调用时使用的参数是否与指定的参数相同。
• 使用 call_args 和 call_args_list 获取调用参数： call_args 属性用于获取最近一次调用 Mock 对象时使用的参数。call_args_list 属性用于获取所有调用 Mock 对象时使用的参数列表。

什么时候应该 Mock？

Mocking 是一种强大的技术，但也应该谨慎使用。过度使用 Mocking 可能会导致测试代码过于复杂，难以维护。一般来说，以下情况适合使用 Mocking：

• 依赖项难以控制： 例如，依赖于一个不稳定的 API 或数据库。
• 依赖项执行时间过长： 例如，依赖于一个需要大量计算的函数。
• 需要模拟复杂的依赖项行为： 例如，需要模拟不同的错误情况或边界情况。
• 需要隔离被测代码： 专注于测试单个模块的功能。

Mocking 的注意事项

• 确保 Mock 对象与真实对象行为一致： Mock 对象的行为应该尽可能地与真实对象的行为一致，否则可能会导致测试结果不准确。
• 避免过度 Mocking： 只 Mock 必要的依赖项，避免过度 Mocking 导致测试代码过于复杂。
• 及时更新 Mock 对象： 当依赖项的实现发生变化时，需要及时更新 Mock 对象，以保证测试的准确性。

代码示例：使用 Mocking 测试一个 API 客户端

假设我们有一个 API 客户端，用于从远程服务器获取数据：

import requests

class APIClient:
    def __init__(self, base_url):
        self.base_url = base_url

    def get_data(self, endpoint):
        url = f"{self.base_url}/{endpoint}"
        response = requests.get(url)
        response.raise_for_status()  # 检查状态码是否为 200
        return response.json()

为了测试 APIClient 类，我们可以使用 Mocking 来模拟 requests.get 函数的行为：

import unittest
from unittest.mock import patch, Mock
from api_client import APIClient
import requests

class TestAPIClient(unittest.TestCase):
    @patch('api_client.requests.get')
    def test_get_data_success(self, mock_get):
        # 配置 Mock 对象的返回值
        mock_response = Mock()
        mock_response.json.return_value = {"data": "Test Data"}
        mock_response.raise_for_status.return_value = None # 防止抛出异常
        mock_get.return_value = mock_response

        # 创建 APIClient 实例
        client = APIClient("http://example.com")

        # 调用 get_data 方法
        data = client.get_data("test_endpoint")

        # 断言结果
        self.assertEqual(data, {"data": "Test Data"})

        # 断言 requests.get 方法被调用，并且参数正确
        mock_get.assert_called_once_with("http://example.com/test_endpoint")

    @patch('api_client.requests.get')
    def test_get_data_failure(self, mock_get):
        # 配置 Mock 对象抛出异常
        mock_get.side_effect = requests.exceptions.HTTPError("API Error")

        # 创建 APIClient 实例
        client = APIClient("http://example.com")

        # 调用 get_data 方法，并捕获异常
        with self.assertRaises(requests.exceptions.HTTPError):
            client.get_data("test_endpoint")

        # 断言 requests.get 方法被调用，并且参数正确
        mock_get.assert_called_once_with("http://example.com/test_endpoint")

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

在这个例子中，我们使用了 patch 装饰器来替换 requests.get 函数。在 test_get_data_success 方法中，我们配置 mock_get 对象返回一个 Mock 对象 mock_response，并设置 mock_response.json() 方法的返回值。然后，我们创建 APIClient 实例，并调用 get_data 方法。最后，我们断言 get_data 方法返回的数据是否与我们设置的返回值相同，并断言 requests.get 方法是否被调用，并且参数是否正确。

在 test_get_data_failure 方法中，我们配置 mock_get 对象抛出一个 requests.exceptions.HTTPError 异常。然后，我们创建 APIClient 实例，并调用 get_data 方法。我们使用 assertRaises 上下文管理器来捕获 get_data 方法抛出的异常，并断言 requests.get 方法是否被调用，并且参数是否正确。

表格：Mocking 技术总结

特性	描述
unittest.mock	Python 标准库提供的 Mocking 工具，允许创建 Mock 对象并配置其行为。
Mock	unittest.mock 模块的核心类，用于创建 Mock 对象。
MagicMock	Mock 的子类，提供了更多的 Magic Methods 的支持。
return_value	设置 Mock 对象的返回值。
side_effect	设置 Mock 对象的副作用，可以是函数、可迭代对象或异常。
patch	装饰器，用于自动替换指定的对象或属性，并在测试结束后恢复原始状态。
assert_called_with	验证 Mock 对象是否被调用，并且调用时使用的参数是否与指定的参数相同。
assert_called_once_with	验证 Mock 对象是否被调用了一次，并且调用时使用的参数是否与指定的参数相同。
call_args	获取最近一次调用 Mock 对象时使用的参数。
call_args_list	获取所有调用 Mock 对象时使用的参数列表。
__call__	使对象可以像函数一样被调用，可以通过替换它来模拟对象的调用行为。
__getattribute__	在每次访问对象的属性时都会被调用，可以通过替换它来拦截属性访问，并返回 Mock 对象或其他值。

结论: Mocking 让测试更具针对性和可控性

今天，我们深入探讨了 Python 单元测试中的 Mocking 机制，重点关注了如何在运行时替换对象的 __call__ 和 __getattribute__ 方法。掌握这些技术，可以帮助我们编写更可靠、可控的单元测试，提高代码质量。通过灵活运用 unittest.mock 模块，我们可以有效地隔离被测代码与其依赖项，专注于测试单个模块的功能，并模拟各种复杂的场景。

希望今天的分享对大家有所帮助！

更多IT精英技术系列讲座，到智猿学院