Patch.object python

The Python unittest.mock module provides the patch.object function, which is used for temporarily replacing or “patching” a specific attribute of an object or class during unit testing. This is commonly used when you want to isolate the code under test from external dependencies, such as databases, APIs, or external services, by replacing or mocking their behavior with controlled substitutes.

Here’s how to use patch.object:

from unittest.mock import patch

# Define a class or object whose attribute you want to patch
class MyClass:
    def method_to_patch(self):
        pass

# Create an instance of the class
my_instance = MyClass()

# Use patch.object as a context manager to temporarily replace the method
with patch.object(my_instance, 'method_to_patch', return_value='mocked_result'):
    # Inside this block, calls to my_instance.method_to_patch will return 'mocked_result'
    result = my_instance.method_to_patch()

# Outside the block, the original behavior is restored
result_after_patch = my_instance.method_to_patch()

# Assert the results
assert result == 'mocked_result'
assert result_after_patch != 'mocked_result'

In this example:

1. We define a class MyClass with a method method_to_patch.
2. We create an instance of MyClass called my_instance.
3. We use patch.object as a context manager to temporarily replace the method_to_patch of my_instance with a mock method that returns 'mocked_result'. Inside the block, any calls to my_instance.method_to_patch will return the mocked result.
4. After exiting the block, the original behavior of my_instance.method_to_patch is restored.
5. We then assert that the result obtained during the patching phase is equal to 'mocked_result', and the result after patching is not equal to 'mocked_result'.

patch.object can be especially useful in unit testing to isolate and control the behavior of external dependencies, making your tests more predictable and less reliant on external factors. It’s a part of Python’s built-in unittest.mock library and is commonly used in conjunction with the unittest testing framework for writing unit tests.