📘 Test Doubles: Stubs, Mocks, and Fakes

🎯 Introduction

Welcome to this exciting tutorial on test doubles! 🎉 Have you ever tried to test code that depends on external services, databases, or APIs? It’s like trying to test a car’s performance on a track that’s still being built! 🏁

Test doubles are your solution - they’re stand-ins for real objects that help you test your code in isolation. Think of them as stunt doubles in movies 🎬 - they look like the real actor but are specifically designed for testing dangerous scenes!

By the end of this tutorial, you’ll be creating test doubles like a pro, making your tests faster, more reliable, and easier to write. Let’s dive in! 🏊‍♂️

📚 Understanding Test Doubles

🤔 What are Test Doubles?

Test doubles are like understudies in theater 🎭 - they step in when the real actor (your actual dependencies) can’t perform. They help you:

• ✨ Test in isolation without external dependencies
• 🚀 Run tests quickly without slow operations
• 🛡️ Create predictable test scenarios
• 🎯 Focus on testing one thing at a time

💡 Types of Test Doubles

There are several types of test doubles, each with its own superpower:

1. Stubs 🎪: Provide canned answers to calls
2. Mocks 🎭: Verify interactions happened correctly
3. Fakes 🎨: Have working implementations but simplified
4. Spies 🕵️: Record information about calls
5. Dummies 🤖: Just fill parameter lists

Today, we’ll focus on the big three: Stubs, Mocks, and Fakes!

🔧 Basic Syntax and Usage

📝 Simple Stub Example

Let’s start with a friendly stub example:

# 👋 Hello, Test Doubles!
from unittest.mock import Mock

# 🎨 Creating a simple stub
def create_weather_stub():
    weather_service = Mock()
    # 🌤️ Stub always returns sunny weather
    weather_service.get_temperature.return_value = 72
    weather_service.get_conditions.return_value = "Sunny ☀️"
    return weather_service

# 🎮 Using our stub
weather = create_weather_stub()
print(f"Temperature: {weather.get_temperature()}°F")  # Always 72!
print(f"Conditions: {weather.get_conditions()}")     # Always Sunny!

💡 Explanation: Stubs provide predetermined responses. Perfect when you need consistent test data!

🎯 Mock with Assertions

Mocks go beyond stubs - they verify interactions:

from unittest.mock import Mock

# 🎭 Create a mock email service
email_service = Mock()

# 🚀 Use the mock in our code
def send_welcome_email(user_email, email_service):
    subject = "Welcome! 🎉"
    body = "Thanks for joining us!"
    email_service.send(user_email, subject, body)

# 🧪 Test with assertions
send_welcome_email("[email protected]", email_service)

# ✅ Verify the email was sent correctly
email_service.send.assert_called_once_with(
    "[email protected]",
    "Welcome! 🎉",
    "Thanks for joining us!"
)

💡 Practical Examples

🛒 Example 1: E-commerce Order Processing

Let’s build a realistic order processing system:

from unittest.mock import Mock, MagicMock
from datetime import datetime
import pytest

# 🛍️ Our order processing system
class OrderProcessor:
    def __init__(self, payment_gateway, inventory_service, email_service):
        self.payment_gateway = payment_gateway
        self.inventory_service = inventory_service
        self.email_service = email_service
    
    def process_order(self, order):
        # 📦 Check inventory
        if not self.inventory_service.check_availability(order.items):
            return {"status": "failed", "reason": "Out of stock 😢"}
        
        # 💳 Process payment
        payment_result = self.payment_gateway.charge(
            order.customer_id,
            order.total_amount
        )
        
        if not payment_result.success:
            return {"status": "failed", "reason": "Payment declined 💳❌"}
        
        # 📧 Send confirmation email
        self.email_service.send_confirmation(
            order.customer_email,
            order.order_id
        )
        
        return {
            "status": "success",
            "message": "Order processed! 🎉",
            "order_id": order.order_id
        }

# 🧪 Testing with test doubles
def test_successful_order():
    # 🎨 Create our test doubles
    payment_gateway = Mock()
    inventory_service = Mock()
    email_service = Mock()
    
    # 🎯 Set up stub responses
    inventory_service.check_availability.return_value = True
    payment_result = Mock()
    payment_result.success = True
    payment_gateway.charge.return_value = payment_result
    
    # 🛒 Create processor and test order
    processor = OrderProcessor(payment_gateway, inventory_service, email_service)
    
    order = Mock()
    order.items = ["Widget", "Gadget"]
    order.customer_id = "CUST123"
    order.total_amount = 99.99
    order.customer_email = "[email protected]"
    order.order_id = "ORD456"
    
    # 🚀 Process the order
    result = processor.process_order(order)
    
    # ✅ Verify success
    assert result["status"] == "success"
    assert "🎉" in result["message"]
    
    # 🔍 Verify all services were called correctly
    inventory_service.check_availability.assert_called_once_with(order.items)
    payment_gateway.charge.assert_called_once_with("CUST123", 99.99)
    email_service.send_confirmation.assert_called_once_with(
        "[email protected]",
        "ORD456"
    )

🎯 Try it yourself: Add a test for when payment fails!

🎮 Example 2: Game Score API with Fakes

Let’s create a fake implementation for testing:

# 🏆 Real API client (would hit actual API)
class GameScoreAPI:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.gamescores.com"
    
    def get_high_scores(self, game_id):
        # 🌐 Would make HTTP request
        pass
    
    def submit_score(self, player_id, score):
        # 📤 Would POST to API
        pass

# 🎨 Fake implementation for testing
class FakeGameScoreAPI:
    def __init__(self):
        self.scores = {}  # 📊 In-memory storage
        
    def get_high_scores(self, game_id):
        # 🎯 Return fake high scores
        if game_id not in self.scores:
            self.scores[game_id] = []
        
        return sorted(self.scores[game_id], 
                     key=lambda x: x['score'], 
                     reverse=True)[:10]
    
    def submit_score(self, game_id, player_id, score):
        # 💾 Store in memory instead of API
        if game_id not in self.scores:
            self.scores[game_id] = []
        
        self.scores[game_id].append({
            'player': player_id,
            'score': score,
            'timestamp': datetime.now(),
            'rank': self._calculate_rank(game_id, score)
        })
        
        return {'success': True, 'rank': self._calculate_rank(game_id, score)}
    
    def _calculate_rank(self, game_id, score):
        # 🏅 Calculate player's rank
        if game_id not in self.scores:
            return 1
        
        higher_scores = sum(1 for s in self.scores[game_id] 
                          if s['score'] > score)
        return higher_scores + 1

# 🎮 Game using our API
class ArcadeGame:
    def __init__(self, score_api):
        self.score_api = score_api
        self.game_id = "space-invaders"
    
    def end_game(self, player_id, final_score):
        # 🎊 Submit score and show result
        result = self.score_api.submit_score(
            self.game_id,
            player_id,
            final_score
        )
        
        if result['rank'] <= 3:
            return f"🏆 NEW HIGH SCORE! Rank #{result['rank']}!"
        elif result['rank'] <= 10:
            return f"🌟 Top 10! Rank #{result['rank']}!"
        else:
            return f"Score submitted! Rank #{result['rank']} 🎮"

# 🧪 Test with fake
def test_arcade_game_scoring():
    # 🎨 Use fake instead of real API
    fake_api = FakeGameScoreAPI()
    game = ArcadeGame(fake_api)
    
    # 🎮 Simulate multiple players
    assert "🏆" in game.end_game("Player1", 1000)  # First player
    assert "🏆" in game.end_game("Player2", 2000)  # New high score!
    assert "🌟" in game.end_game("Player3", 500)   # Lower score
    
    # 🔍 Verify high scores
    high_scores = fake_api.get_high_scores("space-invaders")
    assert len(high_scores) == 3
    assert high_scores[0]['score'] == 2000

🚀 Advanced Concepts

🧙‍♂️ Advanced Mocking with Side Effects

When you need dynamic behavior:

from unittest.mock import Mock, call

# 🎯 Mock with side effects
database_mock = Mock()

# 🎲 Different results each time
database_mock.get_user.side_effect = [
    {"name": "Alice", "status": "active"},
    {"name": "Bob", "status": "inactive"},
    None  # Third call returns None
]

# 🧪 Test the progression
print(database_mock.get_user())  # Alice
print(database_mock.get_user())  # Bob
print(database_mock.get_user())  # None

# 🚀 Mock that raises exceptions
api_mock = Mock()
api_mock.connect.side_effect = ConnectionError("Network timeout! 🌐❌")

try:
    api_mock.connect()
except ConnectionError as e:
    print(f"Caught: {e}")

🏗️ Spy Pattern Implementation

Create a spy that records everything:

class SpyEmailService:
    def __init__(self, real_service=None):
        self.real_service = real_service
        self.sent_emails = []  # 📝 Record all emails
        
    def send(self, to, subject, body):
        # 📸 Record the call
        self.sent_emails.append({
            'to': to,
            'subject': subject,
            'body': body,
            'timestamp': datetime.now()
        })
        
        # 🎯 Optionally call real service
        if self.real_service:
            return self.real_service.send(to, subject, body)
        
        return True  # 🎭 Fake success
    
    def get_sent_count(self):
        return len(self.sent_emails)
    
    def was_email_sent_to(self, email):
        return any(e['to'] == email for e in self.sent_emails)
    
    def get_emails_with_subject(self, subject):
        return [e for e in self.sent_emails if subject in e['subject']]

# 🧪 Using our spy
spy = SpyEmailService()
spy.send("[email protected]", "Welcome! 🎉", "Thanks for joining!")
spy.send("[email protected]", "Alert! 🚨", "System notification")

print(f"Emails sent: {spy.get_sent_count()}")
print(f"Email to user? {spy.was_email_sent_to('[email protected]')}")

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Over-Mocking

# ❌ Wrong - mocking too much!
def test_calculator_add():
    calc = Mock()
    calc.add.return_value = 5
    assert calc.add(2, 3) == 5  # 💥 Not testing anything real!

# ✅ Correct - mock external dependencies only!
def test_calculator_with_logger():
    logger = Mock()  # Mock the logger
    calc = Calculator(logger)  # Real calculator
    
    result = calc.add(2, 3)
    assert result == 5  # Test real logic
    logger.info.assert_called_once()  # Verify logging

🤯 Pitfall 2: Brittle Mock Assertions

# ❌ Too specific - breaks easily!
mock.method.assert_called_with(
    "exact string",
    {"every": "single", "key": "must", "match": "perfectly"}
)

# ✅ Better - focus on what matters!
mock.method.assert_called_once()
args, kwargs = mock.method.call_args

assert "string" in args[0]  # Key part of string
assert kwargs.get("key") == "must"  # Important values only

🛠️ Best Practices

1. 🎯 Mock at boundaries: Only mock external dependencies
2. 📝 Clear test names: test_order_fails_when_payment_declined
3. 🛡️ One mock per concept: Don’t create mega-mocks
4. 🎨 Use appropriate double: Stub for queries, Mock for commands
5. ✨ Keep it simple: Prefer simple fakes over complex mocks

🧪 Hands-On Exercise

🎯 Challenge: Build a Weather Alert System

Create a weather alert system with test doubles:

📋 Requirements:

• ✅ Weather API client (to be mocked)
• 🏷️ Alert service that sends notifications
• 👤 User preferences for alert thresholds
• 📅 Schedule checker for when to send alerts
• 🎨 Different alert types (rain ☔, snow ❄️, heat 🌡️)

🚀 Bonus Points:

• Use all three types of test doubles
• Test error scenarios
• Create a fake that simulates weather patterns

💡 Solution

from unittest.mock import Mock, MagicMock
from datetime import datetime, time
import pytest

# 🌦️ Weather Alert System
class WeatherAlertSystem:
    def __init__(self, weather_api, notification_service, user_prefs):
        self.weather_api = weather_api
        self.notification_service = notification_service
        self.user_prefs = user_prefs
    
    def check_and_alert(self, user_id):
        # 📊 Get user preferences
        prefs = self.user_prefs.get_preferences(user_id)
        if not prefs or not prefs.get('alerts_enabled'):
            return None
        
        # 🌡️ Get current weather
        weather = self.weather_api.get_current_weather(prefs['location'])
        
        alerts_sent = []
        
        # ☔ Check rain alert
        if weather['rain_chance'] > prefs.get('rain_threshold', 70):
            alert = f"☔ Rain alert! {weather['rain_chance']}% chance"
            self.notification_service.send_alert(user_id, alert)
            alerts_sent.append(alert)
        
        # 🌡️ Check temperature alert
        if weather['temperature'] > prefs.get('heat_threshold', 90):
            alert = f"🌡️ Heat alert! {weather['temperature']}°F"
            self.notification_service.send_alert(user_id, alert)
            alerts_sent.append(alert)
        
        # ❄️ Check snow alert
        if weather.get('snow_chance', 0) > prefs.get('snow_threshold', 50):
            alert = f"❄️ Snow alert! {weather['snow_chance']}% chance"
            self.notification_service.send_alert(user_id, alert)
            alerts_sent.append(alert)
        
        return alerts_sent

# 🎨 Fake Weather API for testing
class FakeWeatherAPI:
    def __init__(self):
        self.weather_data = {}
        self.call_count = 0
    
    def set_weather(self, location, weather):
        """Helper method to set test data"""
        self.weather_data[location] = weather
    
    def get_current_weather(self, location):
        self.call_count += 1
        
        # 🎯 Return fake data or default
        return self.weather_data.get(location, {
            'temperature': 72,
            'rain_chance': 10,
            'snow_chance': 0,
            'conditions': 'Sunny ☀️'
        })

# 🧪 Test Suite
class TestWeatherAlertSystem:
    def test_rain_alert_triggered(self):
        # 🎭 Setup mocks
        weather_api = Mock()
        notification_service = Mock()
        user_prefs = Mock()
        
        # 🎯 Configure stubs
        user_prefs.get_preferences.return_value = {
            'alerts_enabled': True,
            'location': 'Seattle',
            'rain_threshold': 60
        }
        
        weather_api.get_current_weather.return_value = {
            'temperature': 65,
            'rain_chance': 85,  # Above threshold!
            'conditions': 'Cloudy ☁️'
        }
        
        # 🚀 Test the system
        alert_system = WeatherAlertSystem(
            weather_api, 
            notification_service, 
            user_prefs
        )
        
        alerts = alert_system.check_and_alert('user123')
        
        # ✅ Verify behavior
        assert len(alerts) == 1
        assert "☔" in alerts[0]
        notification_service.send_alert.assert_called_once()
        
    def test_multiple_alerts_with_fake(self):
        # 🎨 Use fake for more complex scenario
        fake_weather = FakeWeatherAPI()
        notification_service = Mock()
        user_prefs = Mock()
        
        # 🌦️ Set extreme weather
        fake_weather.set_weather('Phoenix', {
            'temperature': 115,  # Hot! 🔥
            'rain_chance': 5,
            'conditions': 'Scorching ☀️'
        })
        
        user_prefs.get_preferences.return_value = {
            'alerts_enabled': True,
            'location': 'Phoenix',
            'heat_threshold': 100
        }
        
        alert_system = WeatherAlertSystem(
            fake_weather,
            notification_service,
            user_prefs
        )
        
        alerts = alert_system.check_and_alert('user456')
        
        # ✅ Should get heat alert
        assert len(alerts) == 1
        assert "🌡️" in alerts[0]
        assert "115°F" in alerts[0]
        
    def test_spy_pattern_for_api_calls(self):
        # 🕵️ Create a spy to track API usage
        class WeatherAPISpy:
            def __init__(self, real_api=None):
                self.real_api = real_api
                self.calls = []
            
            def get_current_weather(self, location):
                self.calls.append({
                    'method': 'get_current_weather',
                    'location': location,
                    'timestamp': datetime.now()
                })
                
                if self.real_api:
                    return self.real_api.get_current_weather(location)
                
                # 🎯 Default response
                return {'temperature': 70, 'rain_chance': 20}
        
        spy = WeatherAPISpy()
        notification_service = Mock()
        user_prefs = Mock()
        
        user_prefs.get_preferences.return_value = {
            'alerts_enabled': True,
            'location': 'Boston'
        }
        
        alert_system = WeatherAlertSystem(spy, notification_service, user_prefs)
        alert_system.check_and_alert('user789')
        
        # 🔍 Verify API was called correctly
        assert len(spy.calls) == 1
        assert spy.calls[0]['location'] == 'Boston'

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

• ✅ Create stubs for predictable test data 🎪
• ✅ Use mocks to verify interactions 🎭
• ✅ Build fakes for complex scenarios 🎨
• ✅ Avoid common testing pitfalls 🛡️
• ✅ Write faster, more reliable tests 🚀

Remember: Test doubles are your friends - they make testing easier, not harder! They’re here to help you write better, more maintainable tests. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered test doubles!

Here’s what to do next:

1. 💻 Practice with the weather alert exercise
2. 🏗️ Refactor existing tests to use test doubles
3. 📚 Explore advanced mocking with pytest-mock
4. 🌟 Learn about property-based testing next!

Remember: Every testing expert started by writing their first mock. Keep practicing, keep learning, and most importantly, keep your tests fast and reliable! 🚀

Happy testing! 🎉🧪✨