Python单元测试中如何优雅校验MagicMock对象的调用逻辑？

Great question! Relying on private Mock internals or hacking unittest.mock's internal collections is super fragile—those implementation details can change between Python versions and break your tests unexpectedly. Let's walk through a clean, maintainable approach to test your to_be_tested function using only public unittest.mock APIs.

First, let's map out exactly what your function does—this helps us target our assertions perfectly:

1. Accesses x.a and x.b properties
2. Adds x.a and x.b (so we need to mock the __add__ magic method)
3. Calls the c() method on the sum result
4. Runs round() on the output of c()
5. Returns the rounded value

Here's the improved test code #

import unittest
from unittest.mock import MagicMock, call

def to_be_tested(x):
    return round((x.a + x.b).c())

class TestToBeTested(unittest.TestCase):
    def test_expected_behavior(self):
        # 1. Set up our mocks with clear return value chains
        x = MagicMock()
        expected_final_result = 7
        
        # Define the behavior step-by-step
        sum_result = MagicMock()
        x.a.__add__.return_value = sum_result  # x.a + x.b returns sum_result
        c_output = MagicMock()
        sum_result.c.return_value = c_output  # sum_result.c() returns c_output
        c_output.__round__.return_value = expected_final_result  # round(c_output) gives our expected value

        # 2. Run the function under test
        result = to_be_tested(x)

        # 3. Validate every part of the call flow using public APIs
        # Verify we accessed x.a and x.b in order
        x.assert_has_calls([
            call.a,
            call.b
        ], any_order=False)
        
        # Verify x.a was added to x.b
        x.a.__add__.assert_called_once_with(x.b)
        
        # Verify we called c() on the sum result
        sum_result.c.assert_called_once()
        
        # Verify round() was called on the c() output
        c_output.__round__.assert_called_once()
        
        # Verify the final result matches our expectation
        self.assertEqual(result, expected_final_result)

Key improvements over your original approach #

• No private property hacks: We use only public MagicMock methods like assert_has_calls, assert_called_once, and assert_called_with to validate behavior. These are stable across Python versions.
• No internal module modifications: Instead of adding __round__ to unittest.mock's internal magic method sets, we directly attach a mock __round__ method to the object that needs it. This is targeted and doesn't pollute global mock behavior.
• Clear, readable assertions: Every step of the function's logic is explicitly verified, making it easy for anyone reading the test to understand what's being checked.

Even more concise version (optional) #

If you prefer a more compact setup, you can chain the return value assignments directly:

def test_concise_version(self):
    x = MagicMock()
    expected_final_result = 7
    
    # Chain all return values in one go
    (x.a.__add__.return_value.c.return_value.__round__.return_value) = expected_final_result
    
    result = to_be_tested(x)
    
    # Same core assertions as before
    x.a.__add__.assert_called_once_with(x.b)
    x.a.__add__.return_value.c.assert_called_once()
    self.assertEqual(result, expected_final_result)

This works because MagicMock automatically creates child mocks for any attribute you access, so you can build the entire call chain in a single line.

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