MockMocking is a technique used in unit testing to isolate the code being tested from its dependencies. When you 'mock' an object, you create a simulated version of that object that mimics its behavior but is under your complete control during the test. This means you don't interact with the actual external services (like databases, network APIs, file systems, or even complex internal components) that your code depends on.
Why use Mocking?
1. Isolation: Ensures that your test failures are due to issues in the code under test, not in its dependencies. If a real database connection fails, it shouldn't cause your business logic test to fail.
2. Speed: Real dependencies can be slow (e.g., network requests, database queries). Mocks run entirely in memory, making tests much faster.
3. Control: You can precisely define how a dependency behaves, allowing you to test specific scenarios, including edge cases, errors, and various return values, which might be hard to reproduce with real dependencies.
4. Cost: Using real external services might incur costs or rate limits.
Key Concepts in Python's `unittest.mock` library:
- `Mock` and `MagicMock`: These are the core classes. `MagicMock` is a subclass of `Mock` that automatically creates mocks for any attribute you try to access (like methods or properties), making it very convenient. Most of the time, `MagicMock` is preferred.
- `return_value`: Defines what a mocked method or function should return when called.
- `side_effect`: Allows you to configure a mock to raise an exception, return values from an iterable, or call a real function when the mock is invoked. This is useful for simulating errors or more complex interactions.
- `patch`: A powerful way to replace objects during tests. It can be used as a decorator or a context manager to temporarily replace classes, functions, or objects in a module with a `Mock` object. This is especially useful for dependencies that are imported and instantiated within the code you're testing.
- Assertions: Mocks provide assertion methods (e.g., `assert_called_once()`, `assert_called_with()`, `assert_any_call()`) to verify that they were called as expected by the code under test.
Example Code
import unittest
from unittest.mock import MagicMock, patch
--- Code to be tested (e.g., in a file named 'my_app.py') ---
class DatabaseClient:
def fetch_user_data(self, user_id):
In a real application, this would connect to a database
and perform a query. We want to avoid this in unit tests.
print(f"[Real DB] Fetching user {user_id}...")
raise NotImplementedError("This method should not be called in tests!")
def update_user_status(self, user_id, status):
print(f"[Real DB] Updating user {user_id} status to {status}...")
raise NotImplementedError("This method should not be called in tests!")
class UserService:
def __init__(self, db_client_instance):
self.db_client = db_client_instance
def get_user_details(self, user_id):
try:
user_data = self.db_client.fetch_user_data(user_id)
if user_data:
return f"User ID: {user_data['id']}, Name: {user_data['name']}"
return "User not found."
except Exception as e:
return f"Error fetching user details: {e}"
def activate_user(self, user_id):
Assume a more complex logic involving multiple DB calls or external services
user = self.db_client.fetch_user_data(user_id)
if not user:
return "User not found for activation."
if user['status'] == 'active':
return "User already active."
self.db_client.update_user_status(user_id, 'active')
return "User activated successfully."
--- Unit tests for UserService (e.g., in a file named 'test_my_app.py') ---
class TestUserService(unittest.TestCase):
def test_get_user_details_existing_user(self):
1. Create a MagicMock object to simulate DatabaseClient
mock_db_client = MagicMock()
2. Configure the mock's 'fetch_user_data' method's return value
mock_db_client.fetch_user_data.return_value = {"id": 1, "name": "Alice"}
3. Instantiate UserService with the mock client
user_service = UserService(mock_db_client)
4. Call the method under test
result = user_service.get_user_details(1)
5. Assert the expected outcome
self.assertEqual(result, "User ID: 1, Name: Alice")
6. Assert that the mock's method was called correctly
mock_db_client.fetch_user_data.assert_called_once_with(1)
def test_get_user_details_non_existing_user(self):
mock_db_client = MagicMock()
Configure the mock to return None, simulating no user found
mock_db_client.fetch_user_data.return_value = None
user_service = UserService(mock_db_client)
result = user_service.get_user_details(99)
self.assertEqual(result, "User not found.")
mock_db_client.fetch_user_data.assert_called_once_with(99)
def test_get_user_details_db_error(self):
mock_db_client = MagicMock()
Configure the mock to raise an exception, simulating a database error
mock_db_client.fetch_user_data.side_effect = ConnectionError("Database offline")
user_service = UserService(mock_db_client)
result = user_service.get_user_details(2)
self.assertEqual(result, "Error fetching user details: Database offline")
mock_db_client.fetch_user_data.assert_called_once_with(2)
def test_activate_user_success(self):
mock_db_client = MagicMock()
Configure for fetch_user_data call
mock_db_client.fetch_user_data.return_value = {"id": 3, "name": "Bob", "status": "inactive"}
Configure for update_user_status call
mock_db_client.update_user_status.return_value = None Update operations often return None
user_service = UserService(mock_db_client)
result = user_service.activate_user(3)
self.assertEqual(result, "User activated successfully.")
mock_db_client.fetch_user_data.assert_called_once_with(3)
mock_db_client.update_user_status.assert_called_once_with(3, 'active')
To run these tests, you would typically use:
if __name__ == '__main__':
unittest.main()
Example of running a single test manually (for demonstration):
test_suite = unittest.TestSuite()
test_suite.addTest(TestUserService('test_get_user_details_existing_user'))
runner = unittest.TextTestRunner()
runner.run(test_suite)