Mocking and Stubbing

Detailed explanation

Mocking and stubbing are essential techniques in unit testing, enabling developers to isolate and test individual components of a software system without relying on external dependencies or complex setups. These techniques involve replacing real dependencies with controlled substitutes, allowing testers to focus on the behavior of the unit under test in a predictable and isolated environment. While the terms are often used interchangeably, there are subtle differences between them.

Stubs

A stub provides canned answers to calls made during a test. Stubs are primarily used to control the state of the system under test. They provide predefined responses to method calls, allowing the test to proceed without actually executing the real dependency's logic. Stubs are simple and primarily focused on providing data.

Consider a scenario where you are testing a service that retrieves user data from a database. Instead of connecting to a real database during the test, you can use a stub to return a predefined user object.

# Example using Python's unittest.mock library
 
import unittest
from unittest.mock import patch
 
class UserDataService:
    def get_user_data(self, user_id):
        # In reality, this would connect to a database
        raise NotImplementedError
 
class UserService:
    def __init__(self, data_service):
        self.data_service = data_service
 
    def get_user_name(self, user_id):
        user_data = self.data_service.get_user_data(user_id)
        return user_data['name']
 
class TestUserService(unittest.TestCase):
    @patch('__main__.UserDataService')
    def test_get_user_name(self, MockUserDataService):
        # Configure the stub to return a specific user
        MockUserDataService.return_value.get_user_data.return_value = {'name': 'John Doe'}
 
        user_service = UserService(MockUserDataService())
        user_name = user_service.get_user_name(123)
 
        self.assertEqual(user_name, 'John Doe')
 
if __name__ == '__main__':
    unittest.main()

In this example, MockUserDataService acts as a stub. It's configured to return a specific dictionary when get_user_data is called, allowing the test to focus solely on the logic within UserService.get_user_name.

Mocks

A mock object goes a step further than a stub. Mocks are used to verify that specific methods were called with expected arguments and in the expected order. They allow you to assert that the interactions between the unit under test and its dependencies occurred as expected. Mocks are more complex and focused on behavior verification.

Building on the previous example, let's say you want to verify that the UserDataService's get_user_data method is called with the correct user_id.

import unittest
from unittest.mock import Mock
 
class UserDataService:
    def get_user_data(self, user_id):
        # In reality, this would connect to a database
        raise NotImplementedError
 
class UserService:
    def __init__(self, data_service):
        self.data_service = data_service
 
    def get_user_name(self, user_id):
        user_data = self.data_service.get_user_data(user_id)
        return user_data['name']
 
class TestUserService(unittest.TestCase):
    def test_get_user_name(self):
        # Create a mock object
        mock_data_service = Mock()
        mock_data_service.get_user_data.return_value = {'name': 'John Doe'}
 
        user_service = UserService(mock_data_service)
        user_name = user_service.get_user_name(123)
 
        self.assertEqual(user_name, 'John Doe')
        # Assert that the get_user_data method was called with the correct argument
        mock_data_service.get_user_data.assert_called_with(123)
 
if __name__ == '__main__':
    unittest.main()

Here, mock_data_service is a mock object. The assert_called_with method verifies that get_user_data was called with the argument 123. This allows you to ensure that the UserService is correctly interacting with its dependency.

When to Use Stubs vs. Mocks

• Stubs: Use stubs when you need to control the input to the unit under test. They are useful for simulating different scenarios and edge cases.
• Mocks: Use mocks when you need to verify the interactions between the unit under test and its dependencies. They are useful for ensuring that the unit under test is calling the correct methods on its dependencies with the correct arguments.

Benefits of Mocking and Stubbing

• Isolation: Isolates the unit under test, preventing dependencies from affecting the test results.
• Speed: Speeds up tests by avoiding slow operations like database access or network calls.
• Predictability: Provides predictable and consistent test results.
• Testability: Enables testing of code that is difficult or impossible to test directly.
• Parallel Execution: Allows tests to be run in parallel without conflicts.

Common Mocking Frameworks and Tools

Many programming languages offer mocking frameworks and libraries to simplify the process of creating and managing mocks and stubs. Some popular options include:

• Python: unittest.mock (built-in), pytest-mock
• Java: Mockito, EasyMock, PowerMock
• JavaScript: Jest, Mocha with Sinon.js
• .NET: Moq, NSubstitute

Best Practices

• Use mocking sparingly: Overusing mocks can lead to brittle tests that are tightly coupled to the implementation details of the code.
• Focus on behavior, not implementation: Mock the behavior of dependencies, not their implementation. This will make your tests more resilient to changes in the underlying code.
• Keep mocks simple: Avoid creating overly complex mocks that are difficult to understand and maintain.
• Use descriptive names: Give your mocks and stubs descriptive names that clearly indicate their purpose.
• Verify only relevant interactions: Only verify the interactions that are essential to the correctness of the unit under test.
• Consider using test doubles: Test doubles are generic terms for stubs, mocks, spies, dummies, and fake objects. Understanding these different types of test doubles can help you choose the right tool for the job.

Real-World Usage

Mocking and stubbing are widely used in various software development scenarios, including:

• Testing API clients: Mocking external API calls to avoid relying on external services during testing.
• Testing database interactions: Stubbing database queries to simulate different data scenarios.
• Testing UI components: Mocking user input and events to test UI logic.
• Testing asynchronous code: Mocking timers and callbacks to control the execution flow of asynchronous code.

By mastering mocking and stubbing techniques, developers can write more effective and reliable unit tests, leading to higher-quality software.

Further reading

• Martin Fowler on Mocks, Stubs and Fakes
• Mockito Documentation
• unittest.mock — Mock object library
• Sinon.JS