Python Mocking & Stubbing – Simulate and Control Code Behavior in Tests

Introduction – Why Use Mocking & Stubbing?

In unit testing, you often need to test a piece of code in isolation. But what if that code:

• Connects to a database?
• Makes HTTP calls?
• Depends on slow, external services?

This is where mocking and stubbing come in.

With Python’s built-in unittest.mock module, you can:

• Replace real objects with controlled stand-ins
• Simulate return values, exceptions, and side effects
• Verify how functions are called

In this guide, you’ll learn:

• The difference between mocking and stubbing
• How to use Mock, MagicMock, and patch()
• How to simulate return values and exceptions
• Best practices and common pitfalls

What Are Mocking and Stubbing?

Stubs are passive (just return data), while mocks are interactive (track usage).

Getting Started with unittest.mock

from unittest.mock import Mock

Create a Simple Mock

mock_func = Mock()
mock_func.return_value = "Hello"

print(mock_func())  # Output: Hello

Setting Return Values and Side Effects

mock = Mock()
mock.get_data.return_value = [1, 2, 3]
mock.raise_error.side_effect = ValueError("Invalid data")

print(mock.get_data())         # [1, 2, 3]
mock.raise_error()             # Raises ValueError

MagicMock – Smarter Mocks with Built-in Magic Methods

from unittest.mock import MagicMock

m = MagicMock()
m.__len__.return_value = 5

print(len(m))  # 5

MagicMock is a subclass of Mock with all dunder methods included.

Using patch() – Replace Objects Temporarily

Replace a Method During Test

from unittest.mock import patch

def fetch_user():
    return "Real user data"

with patch('__main__.fetch_user', return_value="Mocked data"):
    print(fetch_user())  # Mocked data

print(fetch_user())      # Real user data

patch() is perfect for mocking external dependencies, APIs, and class methods.

Patching Objects Inside Classes

class EmailService:
    def send(self):
        return "Email sent"

with patch.object(EmailService, 'send', return_value="Mocked email"):
    service = EmailService()
    print(service.send())  # Mocked email

Verifying Calls and Arguments

assert_called_with()

mock = Mock()
mock("Alice", 42)

mock.assert_called_with("Alice", 42)

call_args, call_count, call_args_list

mock = Mock()
mock(1)
mock(2)

print(mock.call_count)          # 2
print(mock.call_args_list)      # [call(1), call(2)]

Useful for verifying that functions were used correctly.

Real-World Use Case – Mocking API Call

import requests
from unittest.mock import patch

def get_data():
    response = requests.get("https://api.example.com/data")
    return response.json()

@patch("requests.get")
def test_get_data(mock_get):
    mock_get.return_value.json.return_value = {"key": "value"}
    result = get_data()
    assert result == {"key": "value"}

No actual API request is made—pure unit testing!

Mocking vs Stubbing – Summary

Best Practices

Summary – Recap & Next Steps

Python’s unittest.mock gives you the power to test any part of your code in isolation—without relying on databases, APIs, or third-party services.

Key Takeaways:

• Use stubs for predictable outputs
• Use mocks to track function calls and simulate behavior
• patch() helps temporarily replace modules, classes, or functions
• Use MagicMock when mocking magic methods (__len__, __getitem__, etc.)

Real-World Relevance:
Used in unit testing, CI/CD pipelines, test-driven development, and mock API testing.

FAQ – Python Mocking & Stubbing

What is the difference between Mock and MagicMock?

MagicMock includes default implementations for all magic methods like __str__, __len__, __getitem__, etc.

Should I mock everything in a test?

No. Only mock external dependencies—keep tests readable and relevant.

Can I simulate exceptions with mocks?

Yes, using side_effect:

mock.side_effect = ValueError("Boom!")

How do I test if a function was called?

Use:

mock.assert_called()
mock.assert_called_with(args)

Does mocking slow down tests?

No—it makes tests faster by removing external I/O.