+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Home / Tutorials / 🐍 python
Part 199 of 365

📘 Test-Driven Development: TDD Basics

Master test-driven development: tdd basics in Python with practical examples, best practices, and real-world applications 🚀

🚀Intermediate
20 min read

Prerequisites

  • Basic understanding of programming concepts 📝
  • Python installation (3.8+) 🐍
  • VS Code or preferred IDE 💻

What you'll learn

  • Understand the concept fundamentals 🎯
  • Apply the concept in real projects 🏗️
  • Debug common issues 🐛
  • Write clean, Pythonic code ✨

🎯 Introduction

Welcome to the exciting world of Test-Driven Development (TDD)! 🎉 In this guide, we’ll explore how TDD transforms the way you write Python code by putting tests first and letting them guide your development process.

You’ll discover how TDD can revolutionize your coding experience, making it more reliable, maintainable, and enjoyable. Whether you’re building web applications 🌐, data pipelines 📊, or automation scripts 🤖, understanding TDD is essential for writing robust, bug-free code.

By the end of this tutorial, you’ll feel confident using TDD in your own projects! Let’s dive in! 🏊‍♂️

📚 Understanding Test-Driven Development

🤔 What is TDD?

Test-Driven Development is like building with LEGO blocks while following the picture on the box 🎨. You know exactly what you want to build before you start, and you check each step to make sure it matches the plan.

In Python terms, TDD is a development process where you:

  • ✨ Write a failing test first
  • 🚀 Write just enough code to make it pass
  • 🛡️ Refactor to improve the code quality

💡 Why Use TDD?

Here’s why developers love TDD:

  1. Confidence in Code 🔒: Every feature is tested from the start
  2. Better Design 💻: Forces you to think about interfaces first
  3. Living Documentation 📖: Tests show how code should work
  4. Fearless Refactoring 🔧: Change code without breaking things

Real-world example: Imagine building a shopping cart 🛒. With TDD, you’d first write tests for “add item”, then implement it, ensuring it works perfectly before moving on!

🔧 Basic Syntax and Usage

📝 The TDD Cycle: Red-Green-Refactor

Let’s start with a simple example using Python’s built-in unittest:

# 👋 Hello, TDD!
import unittest

# 🎨 Step 1: Write a failing test (RED)
class TestCalculator(unittest.TestCase):
    def test_add_two_numbers(self):
        # 🎯 Test what we want to achieve
        result = add(2, 3)
        self.assertEqual(result, 5)

# 💥 This will fail because add() doesn't exist yet!

# 🚀 Step 2: Write minimal code to pass (GREEN)
def add(a, b):
    return a + b  # ✅ Now the test passes!

# 🛠️ Step 3: Refactor if needed
# Our code is already clean, so we're done!

💡 Explanation: Notice how we write the test first! This ensures we’re building exactly what we need.

🎯 Common TDD Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Arrange-Act-Assert
class TestShoppingCart(unittest.TestCase):
    def test_add_item_to_cart(self):
        # Arrange 📦
        cart = ShoppingCart()
        item = {"name": "Python Book", "price": 29.99, "emoji": "📘"}
        
        # Act 🎬
        cart.add_item(item)
        
        # Assert ✅
        self.assertEqual(len(cart.items), 1)
        self.assertEqual(cart.items[0]["name"], "Python Book")

# 🎨 Pattern 2: Testing exceptions
class TestValidation(unittest.TestCase):
    def test_negative_price_raises_error(self):
        # 🛡️ Ensure our code handles errors properly
        with self.assertRaises(ValueError):
            create_product("Invalid", -10)

# 🔄 Pattern 3: Using pytest (more Pythonic!)
import pytest

def test_user_creation():
    # 😊 pytest uses simple assert statements
    user = User("Alice", "[email protected]")
    assert user.name == "Alice"
    assert user.email == "[email protected]"

💡 Practical Examples

🛒 Example 1: Building a Shopping Cart with TDD

Let’s build something real using TDD:

# 🧪 tests/test_shopping_cart.py
import pytest
from shopping_cart import ShoppingCart, Product

class TestShoppingCart:
    # 🎯 Test 1: Empty cart should have zero total
    def test_empty_cart_total(self):
        cart = ShoppingCart()
        assert cart.get_total() == 0
    
    # 🛍️ Test 2: Adding items should update total
    def test_add_single_item(self):
        cart = ShoppingCart()
        book = Product("Python Cookbook", 39.99, "📚")
        cart.add_item(book)
        
        assert len(cart.items) == 1
        assert cart.get_total() == 39.99
    
    # 🎉 Test 3: Multiple items with quantities
    def test_add_multiple_items(self):
        cart = ShoppingCart()
        coffee = Product("Coffee", 4.99, "☕")
        cart.add_item(coffee, quantity=2)
        
        assert cart.get_total() == 9.98
        assert cart.items[0]["quantity"] == 2

# 🛠️ shopping_cart.py - Implementation driven by tests
class Product:
    def __init__(self, name, price, emoji):
        if price < 0:
            raise ValueError("Price cannot be negative! 💸")
        self.name = name
        self.price = price
        self.emoji = emoji

class ShoppingCart:
    def __init__(self):
        self.items = []
    
    def add_item(self, product, quantity=1):
        # 🎨 Add item with quantity
        self.items.append({
            "product": product,
            "quantity": quantity
        })
        print(f"Added {quantity}x {product.emoji} {product.name} to cart!")
    
    def get_total(self):
        # 💰 Calculate total price
        total = sum(
            item["product"].price * item["quantity"] 
            for item in self.items
        )
        return round(total, 2)

🎯 Try it yourself: Add a remove_item method using TDD! Write the test first!

🎮 Example 2: Game Score System with TDD

Let’s make it fun with a game scoring system:

# 🧪 test_game_score.py
import pytest
from game_score import GameScore, Achievement

class TestGameScore:
    # 🆕 Test new player starts at zero
    def test_new_player_score(self):
        game = GameScore("Player1")
        assert game.score == 0
        assert game.level == 1
        assert game.achievements == []
    
    # 🎯 Test adding points
    def test_add_points(self):
        game = GameScore("Hero")
        game.add_points(100)
        
        assert game.score == 100
        assert "🌟 First Points!" in [a.name for a in game.achievements]
    
    # 📈 Test level up mechanics
    def test_level_up(self):
        game = GameScore("Champion")
        game.add_points(1000)  # Should trigger level up
        
        assert game.level == 2
        assert game.score == 1000
        assert "🏆 Level 2 Achieved!" in [a.name for a in game.achievements]
    
    # 🛡️ Test invalid operations
    def test_negative_points_not_allowed(self):
        game = GameScore("Player")
        with pytest.raises(ValueError, match="Points must be positive"):
            game.add_points(-50)

# 🎮 game_score.py - Built with TDD
from dataclasses import dataclass
from typing import List
from datetime import datetime

@dataclass
class Achievement:
    name: str
    emoji: str
    earned_at: datetime

class GameScore:
    def __init__(self, player_name: str):
        self.player = player_name
        self.score = 0
        self.level = 1
        self.achievements: List[Achievement] = []
        print(f"🎮 {player_name} joined the game!")
    
    def add_points(self, points: int):
        # 🛡️ Validate input
        if points <= 0:
            raise ValueError("Points must be positive! 🚫")
        
        # 🎯 Add points
        old_score = self.score
        self.score += points
        print(f"✨ {self.player} earned {points} points!")
        
        # 🏆 Check achievements
        if old_score == 0 and self.score > 0:
            self._unlock_achievement("🌟 First Points!", "🌟")
        
        # 📈 Check level up
        new_level = (self.score // 1000) + 1
        if new_level > self.level:
            self.level = new_level
            self._unlock_achievement(f"🏆 Level {self.level} Achieved!", "🏆")
    
    def _unlock_achievement(self, name: str, emoji: str):
        achievement = Achievement(name, emoji, datetime.now())
        self.achievements.append(achievement)
        print(f"🎉 Achievement unlocked: {name}")

🚀 Advanced Concepts

🧙‍♂️ Advanced TDD: Mocking and Fixtures

When you’re ready to level up, try these advanced patterns:

# 🎯 Using mocks for external dependencies
from unittest.mock import Mock, patch
import pytest

class TestEmailService:
    @patch('email_service.smtplib.SMTP')
    def test_send_welcome_email(self, mock_smtp):
        # 🪄 Mock external email service
        service = EmailService()
        service.send_welcome("[email protected]")
        
        # ✨ Verify email was "sent"
        mock_smtp.return_value.send_message.assert_called_once()

# 🏗️ Using fixtures for test setup
@pytest.fixture
def sample_user():
    # 🎨 Reusable test data
    return {
        "name": "Test User",
        "email": "[email protected]",
        "emoji": "🧪"
    }

def test_user_creation(sample_user):
    user = User(**sample_user)
    assert user.name == "Test User"
    assert user.emoji == "🧪"

🏗️ Advanced TDD: Property-Based Testing

For the brave developers:

# 🚀 Property-based testing with Hypothesis
from hypothesis import given, strategies as st

class TestMathOperations:
    @given(
        a=st.integers(),
        b=st.integers()
    )
    def test_addition_properties(self, a, b):
        # 🧙‍♂️ Test mathematical properties
        result = add(a, b)
        
        # Commutative property
        assert result == add(b, a)
        
        # Identity property
        assert add(a, 0) == a
        
        # 💫 Hypothesis will generate many test cases!

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Writing Tests After Code

# ❌ Wrong way - writing code first
def calculate_discount(price, discount_percent):
    # Complex logic written without tests 😰
    if discount_percent > 100:
        return 0
    return price * (1 - discount_percent / 100)

# Then trying to add tests... 💥

# ✅ Correct way - TDD approach!
class TestDiscount:
    def test_calculate_10_percent_discount(self):
        # 🎯 Define expected behavior first
        result = calculate_discount(100, 10)
        assert result == 90
    
    def test_discount_cannot_exceed_100_percent(self):
        # 🛡️ Think about edge cases upfront
        result = calculate_discount(100, 150)
        assert result == 0

# Now implement to make tests pass! ✨

🤯 Pitfall 2: Testing Implementation Instead of Behavior

# ❌ Dangerous - testing internal details
def test_user_password_storage():
    user = User("alice", "secret123")
    # 💥 Don't test private implementation!
    assert user._hashed_password == "5ebe2294ecd0e0f..."

# ✅ Safe - test behavior, not implementation
def test_user_authentication():
    user = User("alice", "secret123")
    # ✅ Test what users care about
    assert user.authenticate("secret123") == True
    assert user.authenticate("wrong") == False

🛠️ Best Practices

  1. 🎯 Write One Test at a Time: Focus on one behavior per test
  2. 📝 Descriptive Test Names: test_empty_cart_returns_zero_total not test_1
  3. 🛡️ Test Edge Cases: Empty inputs, negative numbers, None values
  4. 🎨 Keep Tests Simple: If a test is complex, the code might be too
  5. ✨ Fast Tests: Mock external dependencies for speed

🧪 Hands-On Exercise

🎯 Challenge: Build a Todo List with TDD

Create a todo list application using TDD:

📋 Requirements:

  • ✅ Add todos with title and priority
  • 🏷️ Mark todos as complete
  • 📅 Filter by status (pending/completed)
  • 🎨 Each todo needs an emoji based on priority!
  • 🚫 Prevent duplicate todos

🚀 Bonus Points:

  • Add due dates with overdue warnings
  • Implement todo categories
  • Create a productivity score calculator

💡 Solution

🔍 Click to see solution
# 🧪 test_todo_list.py
import pytest
from datetime import datetime, timedelta
from todo_list import TodoList, Todo, Priority

class TestTodoList:
    # 🎯 Test empty list
    def test_new_list_is_empty(self):
        todo_list = TodoList()
        assert len(todo_list.todos) == 0
        assert todo_list.get_pending_count() == 0
    
    # ✅ Test adding todos
    def test_add_todo(self):
        todo_list = TodoList()
        todo_list.add("Learn TDD", Priority.HIGH)
        
        assert len(todo_list.todos) == 1
        assert todo_list.todos[0].title == "Learn TDD"
        assert todo_list.todos[0].emoji == "🔥"  # High priority
    
    # 🚫 Test duplicate prevention
    def test_prevent_duplicates(self):
        todo_list = TodoList()
        todo_list.add("Study Python", Priority.MEDIUM)
        
        with pytest.raises(ValueError, match="already exists"):
            todo_list.add("Study Python", Priority.LOW)
    
    # ✅ Test completion
    def test_mark_complete(self):
        todo_list = TodoList()
        todo_list.add("Write tests", Priority.HIGH)
        todo_list.mark_complete("Write tests")
        
        assert todo_list.todos[0].completed == True
        assert todo_list.get_completed_count() == 1
    
    # 📊 Test productivity score
    def test_productivity_score(self):
        todo_list = TodoList()
        todo_list.add("Task 1", Priority.HIGH)
        todo_list.add("Task 2", Priority.MEDIUM)
        todo_list.mark_complete("Task 1")
        
        score = todo_list.get_productivity_score()
        assert score == 60  # 3 points for high priority / 5 total

# 🛠️ todo_list.py - TDD implementation
from enum import Enum
from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime

class Priority(Enum):
    LOW = ("🟢", 1)
    MEDIUM = ("🟡", 2)
    HIGH = ("🔥", 3)
    
    def __init__(self, emoji, points):
        self.emoji = emoji
        self.points = points

@dataclass
class Todo:
    title: str
    priority: Priority
    completed: bool = False
    created_at: datetime = None
    emoji: str = ""
    
    def __post_init__(self):
        if not self.created_at:
            self.created_at = datetime.now()
        self.emoji = self.priority.emoji

class TodoList:
    def __init__(self):
        self.todos: List[Todo] = []
    
    def add(self, title: str, priority: Priority):
        # 🚫 Check for duplicates
        if any(todo.title == title for todo in self.todos):
            raise ValueError(f"Todo '{title}' already exists! 🚫")
        
        # ✨ Create new todo
        todo = Todo(title, priority)
        self.todos.append(todo)
        print(f"Added: {todo.emoji} {title}")
    
    def mark_complete(self, title: str):
        # 🎯 Find and complete todo
        for todo in self.todos:
            if todo.title == title:
                todo.completed = True
                print(f"✅ Completed: {title}")
                return
        raise ValueError(f"Todo '{title}' not found! 🔍")
    
    def get_pending_count(self) -> int:
        return sum(1 for todo in self.todos if not todo.completed)
    
    def get_completed_count(self) -> int:
        return sum(1 for todo in self.todos if todo.completed)
    
    def get_productivity_score(self) -> int:
        # 📊 Calculate weighted score
        if not self.todos:
            return 100
        
        total_points = sum(todo.priority.points for todo in self.todos)
        completed_points = sum(
            todo.priority.points 
            for todo in self.todos 
            if todo.completed
        )
        
        return int((completed_points / total_points) * 100)

🎓 Key Takeaways

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

  • ✅ Write tests first with confidence 💪
  • ✅ Follow the Red-Green-Refactor cycle like a pro 🔄
  • ✅ Design better code through TDD 🎯
  • ✅ Catch bugs early before they reach production 🐛
  • ✅ Build reliable Python applications with TDD! 🚀

Remember: TDD isn’t just about testing - it’s about designing better code from the start! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered the basics of Test-Driven Development!

Here’s what to do next:

  1. 💻 Practice TDD with your next Python project
  2. 🏗️ Try TDD with web frameworks like Django or Flask
  3. 📚 Explore advanced testing topics like mocking and fixtures
  4. 🌟 Share your TDD journey with other developers!

Remember: Every expert was once a beginner. Keep practicing TDD, and soon it’ll become second nature! 🚀

Happy testing! 🎉🧪✨

Previous Tutorial
📘 Senior Project: Production-Ready Application
Next Tutorial
📘 Unit Testing: Writing Test Cases

More python Tutorials

Part 198

📘 Senior Project: Production-Ready Application

💎Advanced • 25 min read
Part 199 - Currently Reading

📘 Test-Driven Development: TDD Basics

🚀Intermediate • 20 min read
Part 200

📘 Unit Testing: Writing Test Cases

🚀Intermediate • 30 min read
View all 365 python tutorials →

Tutorial Info

Series Progress
Part 199 of 365 55%
Category
🐍 python
Difficulty
🚀Intermediate
Duration
20 min read
Published
July 4, 2025