3.4. Patching Objects

Use patch to replace real objects during tests:

Patching is a technique used in testing to replace real objects with mock versions. This is vital because it allows you to control external dependencies and test your code in isolation. By using the patch function from the unittest.mock module, you can substitute real APIs or database calls with mock objects that return predetermined responses. This makes tests faster, as they don’t rely on actual external services.

Think of patching like using an artificial light bulb instead of a natural one for photography. The artificial bulb can produce a consistent light that you control, while a natural bulb (like sunlight) varies and may lead to unpredictable results. Similarly, by patching, you ensure that your tests produce reliable outcomes.

from unittest.mock import patch

def get_api_data():
    import requests
    response = requests.get('https://api.example.com/data')
    return response.json()

@patch('requests.get')
def test_get_api_data(mock_get):
    mock_get.return_value.json.return_value = {'data': 'mocked'}
    result = get_api_data()
    assert result == {'data': 'mocked'}

In this code example, the function get_api_data makes an HTTP GET request to an external API. By using the @patch decorator, we replace the requests.get method with a mock object mock_get. The line mock_get.return_value.json.return_value = {'data': 'mocked'} tells the mock to return a specific JSON response whenever mock_get is called. This allows you to test the get_api_data function without actually hitting the external API, making the test reliable and faster.

Imagine you're training for a race, and instead of running on the actual track (which could be weather-dependent), you train on a treadmill that simulates the environment. The treadmill helps you practice without external unpredictability. Similarly, the mock object simulates the external API response, allowing you to focus on the logic of your application without outside interference.

Tips for Effective Mocking

● Mock only external dependencies, not the system under test. ● Use context managers or decorators for patching. ● Reset mocks between tests to avoid state leakage.

These tips are best practices for effectively using mocking in your tests. First, you should always mock only those external dependencies, like databases or APIs, instead of the system you are testing. This keeps your tests focused on the internal logic. Second, employing context managers or decorators for patching ensures the mock is reset automatically after each test, maintaining test isolation. Finally, resetting mocks between tests is crucial to prevent any retained state that could lead to false positives or negatives in your test outcomes.

Think of these tips in the context of baking. When you bake a cake, you wouldn’t want the batter from the previous cake interfering with your current mix. Each time you bake, you clean the bowl (resetting mocks) and use fresh ingredients (mocking external dependencies) so that you can ensure the cake turns out correctly. Similarly, implementing these mocking tips ensures your tests are clean and valid.

--