Mocking external services in Django - Step-by-Step Execution

Concept Flow - Mocking external services

Test starts

↓

Patch external service call

↓

Run code that calls external service

↓

Mock intercepts call and returns fake response

↓

Test uses fake response to check behavior

↓

Test ends

This flow shows how a test replaces an external service call with a mock, so the test controls the response and checks code behavior safely.

Execution Sample

Django

from unittest.mock import patch

def test_fetch_data():
    with patch('myapp.services.requests.get') as mock_get:
        mock_get.return_value.status_code = 200
        mock_get.return_value.json.return_value = {'key': 'value'}
        result = fetch_data()
        assert result == {'key': 'value'}

This test replaces the real HTTP GET call with a mock that returns a preset response, then checks the function output.

Execution Table

Step	Action	Mock State	Function Call	Returned Value	Test Assertion
1	Patch 'requests.get' with mock_get	mock_get ready, no calls yet	No call yet	N/A	N/A
2	Call fetch_data(), which calls requests.get	mock_get called once	requests.get() called	Mock response with status 200 and JSON {'key': 'value'}	N/A
3	fetch_data() processes mock response	mock_get still called once	N/A	{'key': 'value'}	N/A
4	Test asserts result equals {'key': 'value'}	mock_get still called once	N/A	{'key': 'value'}	Pass
5	Test ends, patch removed	mock_get removed	N/A	N/A	N/A

💡 Test ends after assertion passes using mocked external service response

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
mock_get.call_count	0	1	1	1
mock_get.return_value.status_code	null	200	200	200
mock_get.return_value.json.return_value	null	{'key': 'value'}	{'key': 'value'}	{'key': 'value'}
result	null	null	{'key': 'value'}	{'key': 'value'}

Key Moments - 3 Insights

Why does the test not make a real HTTP request?

Because the 'requests.get' function is replaced by a mock (see Step 1 and 2 in execution_table), so the real network call is never made.

How does the mock know what to return when called?

We set 'mock_get.return_value.status_code' and 'mock_get.return_value.json.return_value' before calling the function (Step 2), so the mock returns these values.

What happens if the function calls 'requests.get' multiple times?

The mock tracks each call in 'mock_get.call_count' (see variable_tracker), so you can check how many times it was called and control responses accordingly.

Visual Quiz - 3 Questions

Look at the execution_table at Step 2, what is the mock_get.call_count value?

A 2

B 0

C 1

D null

💡 Hint

Check the 'Mock State' column at Step 2 in the execution_table.

At which step does the test check the function's returned value?

A Step 3

B Step 4

C Step 1

D Step 5

💡 Hint

Look for 'Test asserts result equals' in the 'Action' column of the execution_table.

If we did not patch 'requests.get', what would happen during Step 2?

A The test would call the real external service

B The mock would still intercept the call

C The test would fail immediately

D The function would return null

💡 Hint

Refer to the 'Action' and 'Mock State' columns in the execution_table and the key moment about patching.

Concept Snapshot

Mocking external services in Django tests:
- Use unittest.mock.patch to replace external calls
- Set mock return values before calling your code
- Your code calls the mock, not the real service
- Assert your code handles the mock response correctly
- Patch is removed after test ends

Full Transcript

This visual execution shows how to mock external services in Django tests using unittest.mock.patch. The test replaces the real HTTP request function with a mock object. The mock is set up to return a fake response with a status code and JSON data. When the tested function calls the external service, it receives the mock response instead of making a real network call. The test then asserts that the function returns the expected data from the mock. This approach avoids slow or unreliable real service calls during testing and lets you control test scenarios precisely.