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

📘 Unit Testing: Writing Test Cases

Master unit testing: writing test cases in Python with practical examples, best practices, and real-world applications 🚀

🚀Intermediate
30 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 world of unit testing! 🎉 In this guide, we’ll explore how to write effective test cases that catch bugs before your users do.

You’ll discover how unit testing can transform your Python development experience. Whether you’re building web applications 🌐, data pipelines 🖥️, or libraries 📚, understanding unit testing is essential for writing robust, maintainable code.

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

📚 Understanding Unit Testing

🤔 What is Unit Testing?

Unit testing is like having a quality inspector for each piece of your code 🎨. Think of it as a safety net that catches bugs before they reach production - like spell-checking each word before publishing a book!

In Python terms, unit testing means writing small programs that verify your functions and classes work correctly. This means you can:

  • ✨ Catch bugs early in development
  • 🚀 Refactor with confidence
  • 🛡️ Ensure code quality over time

💡 Why Use Unit Testing?

Here’s why developers love unit testing:

  1. Bug Prevention 🔒: Catch errors before deployment
  2. Documentation 💻: Tests show how code should be used
  3. Refactoring Safety 📖: Change code without breaking features
  4. Development Speed 🔧: Debug faster with focused tests

Real-world example: Imagine building a shopping cart 🛒. With unit tests, you can verify that adding items, calculating totals, and applying discounts all work correctly before going live!

🔧 Basic Syntax and Usage

📝 Simple Example with unittest

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

# 👋 Hello, Unit Testing!
import unittest

# 🎨 The function we want to test
def add_numbers(a, b):
    """Add two numbers together"""
    return a + b

# 🧪 Our test class
class TestMathFunctions(unittest.TestCase):
    def test_add_positive_numbers(self):
        # 🎯 Test with positive numbers
        result = add_numbers(2, 3)
        self.assertEqual(result, 5)  # ✅ Should be 5!
    
    def test_add_negative_numbers(self):
        # 🌡️ Test with negative numbers
        result = add_numbers(-1, -1)
        self.assertEqual(result, -2)  # ✅ Should be -2!

# 🚀 Run the tests
if __name__ == '__main__':
    unittest.main()

💡 Explanation: Notice how each test method starts with test_. This tells unittest which methods to run!

🎯 Common Testing Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Testing with pytest (more Pythonic!)
import pytest

def calculate_discount(price, discount_percent):
    """Calculate discounted price"""
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Discount must be between 0 and 100")
    return price * (1 - discount_percent / 100)

# 🎨 Pattern 2: Multiple test cases
def test_normal_discount():
    # 💰 20% off $100
    assert calculate_discount(100, 20) == 80

def test_no_discount():
    # 🎯 0% discount
    assert calculate_discount(100, 0) == 100

def test_invalid_discount():
    # ⚠️ Test error handling
    with pytest.raises(ValueError):
        calculate_discount(100, 150)  # 💥 Too high!

# 🔄 Pattern 3: Parameterized testing
@pytest.mark.parametrize("price,discount,expected", [
    (100, 10, 90),    # 10% off
    (50, 50, 25),     # 50% off  
    (200, 25, 150),   # 25% off
])
def test_various_discounts(price, discount, expected):
    assert calculate_discount(price, discount) == expected

💡 Practical Examples

🛒 Example 1: Shopping Cart Testing

Let’s build and test something real:

# 🛍️ Our shopping cart class
class ShoppingCart:
    def __init__(self):
        self.items = []  # 📦 Empty cart
        
    def add_item(self, name, price, quantity=1):
        """Add item to cart"""
        self.items.append({
            'name': name,
            'price': price,
            'quantity': quantity,
            'emoji': '🛍️'
        })
        print(f"Added {quantity}x {name} to cart! 🛒")
    
    def get_total(self):
        """Calculate total price"""
        return sum(item['price'] * item['quantity'] 
                  for item in self.items)
    
    def apply_coupon(self, code):
        """Apply discount coupon"""
        discounts = {
            'SAVE10': 0.1,    # 10% off
            'SAVE20': 0.2,    # 20% off
            'HALFOFF': 0.5    # 50% off! 🎉
        }
        if code in discounts:
            discount = self.get_total() * discounts[code]
            print(f"💰 Discount applied: ${discount:.2f}")
            return discount
        return 0

# 🧪 Test our shopping cart
import pytest

class TestShoppingCart:
    def setup_method(self):
        # 🎯 Fresh cart for each test
        self.cart = ShoppingCart()
    
    def test_empty_cart(self):
        # 📦 Empty cart should have total of 0
        assert self.cart.get_total() == 0
        assert len(self.cart.items) == 0
    
    def test_add_single_item(self):
        # ➕ Add one item
        self.cart.add_item("Python Book", 29.99)
        assert self.cart.get_total() == 29.99
        assert len(self.cart.items) == 1
    
    def test_add_multiple_items(self):
        # 🛒 Add several items
        self.cart.add_item("Coffee", 4.99, 2)  # ☕ 2 coffees
        self.cart.add_item("Keyboard", 79.99)  # ⌨️ 1 keyboard
        expected = (4.99 * 2) + 79.99
        assert self.cart.get_total() == expected
    
    def test_valid_coupon(self):
        # 🎟️ Test discount coupon
        self.cart.add_item("Laptop", 1000)
        discount = self.cart.apply_coupon('SAVE20')
        assert discount == 200  # 20% of $1000
    
    def test_invalid_coupon(self):
        # ❌ Invalid coupon code
        self.cart.add_item("Mouse", 25)
        discount = self.cart.apply_coupon('FAKECODE')
        assert discount == 0  # No discount applied

🎯 Try it yourself: Add a remove_item method and test it!

🎮 Example 2: Game Score Testing

Let’s make testing fun with a game example:

# 🏆 Game score tracker
class GameScoreTracker:
    def __init__(self):
        self.players = {}  # 👥 Player scores
        self.high_score = 0  # 🏆 Current high score
    
    def add_player(self, name):
        """Add new player"""
        if name in self.players:
            raise ValueError(f"Player {name} already exists! 😅")
        self.players[name] = {
            'score': 0,
            'level': 1,
            'achievements': ['🌟 Welcome!']
        }
        print(f"🎮 {name} joined the game!")
    
    def add_points(self, player, points):
        """Award points to player"""
        if player not in self.players:
            raise ValueError(f"Player {player} not found! 🤔")
        
        self.players[player]['score'] += points
        
        # 🎊 Level up every 100 points
        new_level = (self.players[player]['score'] // 100) + 1
        if new_level > self.players[player]['level']:
            self.players[player]['level'] = new_level
            self.players[player]['achievements'].append(
                f'🏆 Level {new_level} Master!'
            )
        
        # 🏆 Update high score
        if self.players[player]['score'] > self.high_score:
            self.high_score = self.players[player]['score']
            print(f"🎉 New high score: {self.high_score}!")
    
    def get_leaderboard(self):
        """Get sorted leaderboard"""
        return sorted(
            self.players.items(),
            key=lambda x: x[1]['score'],
            reverse=True
        )

# 🧪 Test our game tracker
def test_add_new_player():
    game = GameScoreTracker()
    game.add_player("Alice")
    
    assert "Alice" in game.players
    assert game.players["Alice"]['score'] == 0
    assert game.players["Alice"]['level'] == 1

def test_duplicate_player():
    game = GameScoreTracker()
    game.add_player("Bob")
    
    # 😱 Should raise error for duplicate
    with pytest.raises(ValueError):
        game.add_player("Bob")

def test_scoring_and_leveling():
    game = GameScoreTracker()
    game.add_player("Charlie")
    
    # 🎯 Add points
    game.add_points("Charlie", 50)
    assert game.players["Charlie"]['score'] == 50
    assert game.players["Charlie"]['level'] == 1
    
    # 🎊 Level up!
    game.add_points("Charlie", 60)  # Total: 110
    assert game.players["Charlie"]['score'] == 110
    assert game.players["Charlie"]['level'] == 2
    assert '🏆 Level 2 Master!' in game.players["Charlie"]['achievements']

def test_leaderboard():
    game = GameScoreTracker()
    
    # 👥 Add multiple players
    game.add_player("Alice")
    game.add_player("Bob")
    game.add_player("Charlie")
    
    # 🎮 Give them scores
    game.add_points("Bob", 150)
    game.add_points("Alice", 200)
    game.add_points("Charlie", 100)
    
    # 📊 Check leaderboard order
    leaderboard = game.get_leaderboard()
    assert leaderboard[0][0] == "Alice"  # 🥇
    assert leaderboard[1][0] == "Bob"    # 🥈
    assert leaderboard[2][0] == "Charlie" # 🥉

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Mocking External Dependencies

When you’re ready to level up, try mocking:

# 🎯 Mocking external services
from unittest.mock import Mock, patch
import requests

class WeatherService:
    def get_temperature(self, city):
        """Get temperature from API"""
        response = requests.get(f"http://api.weather.com/{city}")
        return response.json()['temperature']

# 🪄 Mock the external API call
def test_weather_service():
    service = WeatherService()
    
    # 🎭 Create a mock response
    with patch('requests.get') as mock_get:
        mock_response = Mock()
        mock_response.json.return_value = {'temperature': 72}
        mock_get.return_value = mock_response
        
        temp = service.get_temperature("Seattle")
        assert temp == 72
        
        # ✅ Verify the API was called correctly
        mock_get.assert_called_with("http://api.weather.com/Seattle")

🏗️ Advanced Topic 2: Test Fixtures and Setup

For the brave developers:

# 🚀 Advanced fixtures with pytest
import pytest
import tempfile
import os

@pytest.fixture
def temp_database():
    """Create temporary database for testing"""
    # 📁 Create temp file
    db_fd, db_path = tempfile.mkstemp()
    
    # 🎯 Setup code here
    print(f"✨ Created test database at {db_path}")
    
    yield db_path  # 🎁 Give path to test
    
    # 🧹 Cleanup after test
    os.close(db_fd)
    os.unlink(db_path)
    print("🗑️ Cleaned up test database")

def test_with_database(temp_database):
    # 💾 Use the temporary database
    assert os.path.exists(temp_database)
    # Your database tests here! 🎮

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Testing Implementation Instead of Behavior

# ❌ Wrong way - testing internal details
def test_bad_approach():
    cart = ShoppingCart()
    cart.add_item("Book", 10)
    # 😰 Don't test internal structure!
    assert cart.items[0]['name'] == "Book"

# ✅ Correct way - test behavior
def test_good_approach():
    cart = ShoppingCart()
    cart.add_item("Book", 10)
    # 🛡️ Test what matters to users
    assert cart.get_total() == 10

🤯 Pitfall 2: Not Testing Edge Cases

# ❌ Incomplete testing
def divide(a, b):
    return a / b

def test_incomplete():
    assert divide(10, 2) == 5  # ✅ Happy path only

# ✅ Complete testing
def test_complete():
    # 🎯 Normal case
    assert divide(10, 2) == 5
    
    # 🌡️ Edge cases
    assert divide(0, 5) == 0
    assert divide(-10, 2) == -5
    
    # 💥 Error case
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

🛠️ Best Practices

  1. 🎯 One Thing Per Test: Each test should verify one behavior
  2. 📝 Descriptive Names: test_cart_total_with_multiple_items not test1
  3. 🛡️ Test Edge Cases: Empty inputs, None values, errors
  4. 🎨 Arrange-Act-Assert: Setup, execute, verify pattern
  5. ✨ Keep Tests Fast: Mock external dependencies

🧪 Hands-On Exercise

🎯 Challenge: Build a Password Validator Test Suite

Create comprehensive tests for a password validator:

📋 Requirements:

  • ✅ Password must be 8+ characters
  • 🔤 Must contain uppercase and lowercase
  • 🔢 Must contain at least one number
  • 🎨 Must contain special character
  • 🚫 No spaces allowed

🚀 Bonus Points:

  • Test multiple valid passwords
  • Test edge cases (empty, None, very long)
  • Use parameterized testing

💡 Solution

🔍 Click to see solution
# 🎯 Our password validator
import re

class PasswordValidator:
    def __init__(self):
        self.min_length = 8
        self.errors = []
    
    def validate(self, password):
        """Validate password strength"""
        self.errors = []  # 🧹 Clear previous errors
        
        if not password:
            self.errors.append("❌ Password cannot be empty")
            return False
        
        # 📏 Check length
        if len(password) < self.min_length:
            self.errors.append(f"❌ Must be at least {self.min_length} characters")
        
        # 🔤 Check uppercase
        if not re.search(r'[A-Z]', password):
            self.errors.append("❌ Must contain uppercase letter")
        
        # 🔡 Check lowercase
        if not re.search(r'[a-z]', password):
            self.errors.append("❌ Must contain lowercase letter")
        
        # 🔢 Check number
        if not re.search(r'\d', password):
            self.errors.append("❌ Must contain at least one number")
        
        # 🎨 Check special character
        if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
            self.errors.append("❌ Must contain special character")
        
        # 🚫 Check spaces
        if ' ' in password:
            self.errors.append("❌ Cannot contain spaces")
        
        return len(self.errors) == 0

# 🧪 Comprehensive test suite
import pytest

class TestPasswordValidator:
    def setup_method(self):
        self.validator = PasswordValidator()
    
    # ✅ Test valid passwords
    @pytest.mark.parametrize("password", [
        "StrongP@ss123",      # Perfect! 💪
        "MyS3cret!Pass",      # Also good! 🛡️
        "Test123$Password",   # Long and strong! 🎯
    ])
    def test_valid_passwords(self, password):
        assert self.validator.validate(password) == True
        assert len(self.validator.errors) == 0
    
    # ❌ Test invalid passwords
    def test_empty_password(self):
        assert self.validator.validate("") == False
        assert "❌ Password cannot be empty" in self.validator.errors
    
    def test_none_password(self):
        assert self.validator.validate(None) == False
    
    def test_too_short(self):
        assert self.validator.validate("Sh0rt!") == False
        assert any("8 characters" in error for error in self.validator.errors)
    
    def test_missing_uppercase(self):
        assert self.validator.validate("lowercase123!") == False
        assert any("uppercase" in error for error in self.validator.errors)
    
    def test_missing_lowercase(self):
        assert self.validator.validate("UPPERCASE123!") == False
        assert any("lowercase" in error for error in self.validator.errors)
    
    def test_missing_number(self):
        assert self.validator.validate("NoNumbers!Here") == False
        assert any("number" in error for error in self.validator.errors)
    
    def test_missing_special(self):
        assert self.validator.validate("NoSpecial123") == False
        assert any("special character" in error for error in self.validator.errors)
    
    def test_contains_space(self):
        assert self.validator.validate("Has Space123!") == False
        assert any("spaces" in error for error in self.validator.errors)
    
    # 🎯 Test multiple errors
    def test_multiple_errors(self):
        assert self.validator.validate("bad") == False
        assert len(self.validator.errors) >= 4  # Multiple issues!
    
    # 🚀 Edge case: very long password
    def test_very_long_password(self):
        long_pass = "A" * 100 + "bcdef123!@#"
        assert self.validator.validate(long_pass) == True

🎓 Key Takeaways

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

  • ✅ Write unit tests with confidence 💪
  • ✅ Use pytest and unittest effectively 🛡️
  • ✅ Test edge cases and error conditions 🎯
  • ✅ Mock external dependencies like a pro 🐛
  • ✅ Build reliable Python applications with tests! 🚀

Remember: Tests are your friends, not your enemies! They’re here to help you write better code. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered unit testing basics!

Here’s what to do next:

  1. 💻 Practice with the password validator exercise
  2. 🏗️ Add tests to your existing Python projects
  3. 📚 Learn about test coverage tools like coverage.py
  4. 🌟 Explore advanced topics like integration testing

Remember: Every Python expert writes tests. Keep testing, keep learning, and most importantly, have fun! 🚀

Happy testing! 🎉🚀✨

Previous Tutorial
📘 Test-Driven Development: TDD Basics
Next Tutorial
📘 Test Fixtures: setUp and tearDown

More python Tutorials

Part 199

📘 Test-Driven Development: TDD Basics

🚀Intermediate • 20 min read
Part 200 - Currently Reading

📘 Unit Testing: Writing Test Cases

🚀Intermediate • 30 min read
Part 201

📘 Test Fixtures: setUp and tearDown

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

Tutorial Info

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