📘 Pytest Parametrization: Multiple Test Cases

🎯 Introduction

Welcome to this exciting tutorial on pytest parametrization! 🎉 Have you ever found yourself writing the same test over and over again with different inputs? It’s like being a chef who has to cook the same dish 100 times just to test different spice levels! 🍳

Today, we’ll discover how pytest parametrization can transform your testing experience. Whether you’re testing calculators 🧮, validating user inputs 🔐, or checking edge cases 🔍, parametrization makes your tests cleaner, more maintainable, and way more powerful!

By the end of this tutorial, you’ll be writing tests that cover dozens of scenarios with minimal code. Let’s dive in! 🏊‍♂️

📚 Understanding Pytest Parametrization

🤔 What is Parametrization?

Parametrization is like having a magic test multiplier! 🎩✨ Think of it as a factory that takes one test function and creates multiple test cases from it automatically.

Instead of writing:

def test_add_positive():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, -1) == -2

def test_add_zero():
    assert add(0, 5) == 5

You write ONE test that handles ALL cases! 🚀

💡 Why Use Parametrization?

Here’s why developers love parametrization:

1. DRY Principle 🌵: Don’t Repeat Yourself - write once, test many
2. Better Coverage 📊: Easy to add new test cases
3. Cleaner Code ✨: Less duplication, more readability
4. Time Saver ⏰: Add test cases in seconds
5. Edge Case Hunter 🎯: Catch those sneaky bugs

Real-world example: Imagine testing a password validator 🔒. With parametrization, you can test weak passwords, strong passwords, special characters, and length requirements all in one elegant test!

🔧 Basic Syntax and Usage

📝 Simple Parametrization

Let’s start with a friendly example:

import pytest

# 👋 Hello, parametrization!
@pytest.mark.parametrize("input,expected", [
    (2, 4),      # 🔢 Test case 1
    (3, 9),      # 🔢 Test case 2
    (4, 16),     # 🔢 Test case 3
    (5, 25),     # 🔢 Test case 4
])
def test_square(input, expected):
    """✨ One test, multiple cases!"""
    assert input ** 2 == expected

💡 Explanation: The @pytest.mark.parametrize decorator takes two arguments:

• Parameter names as a string (comma-separated)
• A list of tuples with test data

🎯 Common Patterns

Here are patterns you’ll use daily:

# 🏗️ Pattern 1: Multiple parameters
@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),       # ➕ Addition
    (10, -5, 5),     # ➖ Subtraction-like
    (0, 0, 0),       # 🎯 Edge case
])
def test_addition(a, b, expected):
    assert a + b == expected

# 🎨 Pattern 2: Single parameter with descriptive IDs
@pytest.mark.parametrize("password", [
    "short",              # 🚫 Too short
    "nouppercase123",     # 🚫 No uppercase
    "NOLOWERCASE123",     # 🚫 No lowercase
    "NoNumbers!",         # 🚫 No numbers
    "ValidPass123!",      # ✅ Perfect!
], ids=["too_short", "no_upper", "no_lower", "no_digits", "valid"])
def test_password_strength(password):
    # Your password validation logic here
    pass

# 🔄 Pattern 3: Using pytest.param for better organization
@pytest.mark.parametrize("test_input,expected", [
    pytest.param(0, 0, id="zero"),
    pytest.param(1, 1, id="one"),
    pytest.param(-1, 1, id="negative"),
    pytest.param(100, 10000, marks=pytest.mark.slow),  # 🐌 Mark slow tests
])
def test_square_advanced(test_input, expected):
    assert test_input ** 2 == expected

💡 Practical Examples

🛒 Example 1: E-commerce Price Calculator

Let’s build something real - a shopping cart discount calculator:

import pytest
from decimal import Decimal

# 🛍️ Our discount calculator
class DiscountCalculator:
    def calculate_final_price(self, price, discount_percent, is_vip=False):
        """Calculate price after discount 💰"""
        discount = Decimal(str(price)) * Decimal(str(discount_percent)) / 100
        final_price = Decimal(str(price)) - discount
        
        # 🌟 VIP members get extra 5% off!
        if is_vip:
            final_price *= Decimal('0.95')
        
        return float(final_price)

# 🧪 Test with multiple scenarios
@pytest.mark.parametrize("price,discount,is_vip,expected", [
    # Regular customers
    (100, 0, False, 100.00),      # 🏷️ No discount
    (100, 10, False, 90.00),      # 🏷️ 10% off
    (100, 50, False, 50.00),      # 🏷️ Half price sale!
    
    # VIP customers get extra perks! 🌟
    (100, 0, True, 95.00),        # 👑 VIP base discount
    (100, 10, True, 85.50),       # 👑 VIP + 10% off
    (100, 50, True, 47.50),       # 👑 VIP + half price!
    
    # Edge cases 🎯
    (0, 10, False, 0),            # 🆓 Free item
    (49.99, 20, False, 39.99),    # 💵 Decimal prices
])
def test_discount_calculator(price, discount, is_vip, expected):
    calc = DiscountCalculator()
    result = calc.calculate_final_price(price, discount, is_vip)
    assert abs(result - expected) < 0.01  # 💰 Handle floating point precision

# 🎉 Run with: pytest -v to see all test cases!

🎯 Try it yourself: Add test cases for invalid inputs like negative prices or discounts over 100%!

🎮 Example 2: Game Character Stats Validator

Let’s make testing fun with a game character system:

import pytest

# 🎮 Game character stats
class GameCharacter:
    def __init__(self, name, level, health, attack, defense):
        self.name = name
        self.level = level
        self.health = health
        self.attack = attack
        self.defense = defense
    
    def calculate_power_level(self):
        """Calculate overall power level 💪"""
        return (self.health * 0.5) + (self.attack * 2) + (self.defense * 1.5)
    
    def can_defeat(self, enemy_power):
        """Check if character can win ⚔️"""
        return self.calculate_power_level() > enemy_power

# 🧪 Test different character builds
@pytest.mark.parametrize("name,level,health,attack,defense,expected_power", [
    # Different character classes 🎭
    ("Warrior", 10, 100, 15, 20, 110.0),     # 🛡️ Tank build
    ("Mage", 10, 60, 25, 10, 95.0),          # 🧙‍♂️ Glass cannon
    ("Rogue", 10, 80, 20, 15, 82.5),         # 🗡️ Balanced
    ("Paladin", 10, 90, 18, 18, 108.0),      # ⚔️ All-rounder
    
    # Level progression 📈
    ("Noob", 1, 30, 5, 5, 27.5),             # 👶 Beginner
    ("Pro", 50, 500, 100, 80, 570.0),        # 🏆 End game
    ("Legend", 99, 999, 200, 150, 924.5),    # 🌟 Max level!
])
def test_character_power_calculation(name, level, health, attack, defense, expected_power):
    character = GameCharacter(name, level, health, attack, defense)
    assert character.calculate_power_level() == expected_power
    print(f"  {name} has {expected_power} power! {'💪' * (level // 20)}")

# 🎯 Test combat scenarios
@pytest.mark.parametrize("attacker_stats,enemy_power,should_win", [
    ((100, 20, 15), 80, True),    # 💪 Strong vs weak
    ((60, 10, 10), 100, False),   # 😰 Weak vs strong
    ((80, 15, 15), 60, True),     # ⚔️ Fair fight
], ids=["strong_wins", "weak_loses", "balanced_fight"])
def test_combat_outcomes(attacker_stats, enemy_power, should_win):
    health, attack, defense = attacker_stats
    hero = GameCharacter("Hero", 10, health, attack, defense)
    assert hero.can_defeat(enemy_power) == should_win

🚀 Advanced Concepts

🧙‍♂️ Multiple Parameter Sets

When you’re ready to level up, combine multiple parametrize decorators:

# 🎯 Test all combinations!
@pytest.mark.parametrize("browser", ["chrome", "firefox", "safari"])
@pytest.mark.parametrize("resolution", ["mobile", "tablet", "desktop"])
@pytest.mark.parametrize("theme", ["light", "dark"])
def test_ui_compatibility(browser, resolution, theme):
    """Test UI in all possible combinations 🌈"""
    print(f"Testing {theme} theme on {browser} at {resolution} resolution")
    # This creates 3 × 3 × 2 = 18 test cases! 🚀

# 🪄 Using indirect parametrization for fixtures
@pytest.mark.parametrize("db_type", ["sqlite", "postgres", "mysql"], indirect=True)
def test_database_operations(db_type):
    """Test with different database backends 🗄️"""
    # db_type is actually a fixture that sets up the database!
    pass

🏗️ Dynamic Parametrization

For the brave developers - generate test cases dynamically:

# 🚀 Generate test cases programmatically
def generate_fibonacci_tests():
    """Generate Fibonacci test cases 🔢"""
    fib_cases = [
        (0, 0),
        (1, 1),
        (2, 1),
        (3, 2),
        (4, 3),
        (5, 5),
        (6, 8),
        (10, 55),
    ]
    return [(n, expected) for n, expected in fib_cases]

@pytest.mark.parametrize("n,expected", generate_fibonacci_tests())
def test_fibonacci(n, expected):
    """Test Fibonacci sequence 🌀"""
    def fib(n):
        if n <= 1:
            return n
        return fib(n-1) + fib(n-2)
    
    assert fib(n) == expected

# 💫 Parametrize with custom objects
class TestCase:
    def __init__(self, input_data, expected, description):
        self.input_data = input_data
        self.expected = expected
        self.description = description
    
    def __repr__(self):
        return f"<{self.description}>"

test_scenarios = [
    TestCase([1, 2, 3], 6, "positive_numbers"),
    TestCase([-1, -2, -3], -6, "negative_numbers"),
    TestCase([0, 0, 0], 0, "all_zeros"),
    TestCase([1, -1, 2, -2], 0, "mixed_numbers"),
]

@pytest.mark.parametrize("test_case", test_scenarios)
def test_sum_with_objects(test_case):
    """Test sum with custom test objects 🎁"""
    result = sum(test_case.input_data)
    assert result == test_case.expected

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Forgetting String Quotes in Parameter Names

# ❌ Wrong - This will cause an error!
@pytest.mark.parametrize(input, expected, [(1, 2), (2, 4)])
def test_double(input, expected):
    assert input * 2 == expected

# ✅ Correct - Parameter names must be strings!
@pytest.mark.parametrize("input,expected", [(1, 2), (2, 4)])
def test_double(input, expected):
    assert input * 2 == expected

🤯 Pitfall 2: Mutable Default Arguments

# ❌ Dangerous - Shared mutable state!
@pytest.mark.parametrize("items,default", [
    ([1, 2, 3], []),  # 💥 Empty list is mutable!
])
def test_append_items(items, default):
    for item in items:
        default.append(item)  # Modifies the shared list!
    return default

# ✅ Safe - Create new instances!
@pytest.mark.parametrize("items", [
    [1, 2, 3],
    [4, 5, 6],
])
def test_append_items_safe(items):
    result = []  # ✨ Fresh list each time
    for item in items:
        result.append(item)
    assert len(result) == len(items)

🎭 Pitfall 3: Too Many Test Cases

# ❌ Overwhelming - 1000 test cases!
@pytest.mark.parametrize("x", range(1000))
def test_something(x):
    assert x >= 0

# ✅ Strategic - Test boundaries and samples!
@pytest.mark.parametrize("x", [
    0,      # 🎯 Lower boundary
    1,      # 🎯 Just above lower
    50,     # 🎯 Middle value
    99,     # 🎯 Just below upper
    100,    # 🎯 Upper boundary
])
def test_something_smart(x):
    assert 0 <= x <= 100

🛠️ Best Practices

1. 🎯 Use Descriptive IDs: Help identify failing tests

   @pytest.mark.parametrize("input,expected", [
       (2, 4),
       (3, 9),
   ], ids=["two_squared", "three_squared"])

2. 📝 Group Related Tests: Keep similar test cases together

   # Group by test category
   POSITIVE_CASES = [(1, 1), (2, 4), (3, 9)]
   NEGATIVE_CASES = [(-1, 1), (-2, 4), (-3, 9)]
   EDGE_CASES = [(0, 0), (1000000, 1000000000000)]

3. 🛡️ Test Edge Cases: Always include boundaries

4. 🎨 Keep It Readable: Don’t sacrifice clarity for cleverness

5. ✨ Use pytest.param: For better organization and marking

🧪 Hands-On Exercise

🎯 Challenge: Build a URL Validator Test Suite

Create a comprehensive test suite for a URL validator:

📋 Requirements:

• ✅ Test valid URLs (http, https, ftp)
• 🚫 Test invalid URLs (missing protocol, invalid characters)
• 🌐 Test different domains (.com, .org, .io)
• 📏 Test URL length limits
• 🎨 Each test needs clear identification!

🚀 Bonus Points:

• Add tests for query parameters
• Test international domains
• Include port number validation

💡 Solution

import pytest
import re

# 🌐 Our URL validator
class URLValidator:
    def __init__(self):
        # Simple regex for demonstration 🎯
        self.url_pattern = re.compile(
            r'^(https?|ftp)://'  # Protocol
            r'([a-zA-Z0-9.-]+)'  # Domain
            r'(\.[a-zA-Z]{2,})'  # TLD
            r'(:[0-9]+)?'        # Optional port
            r'(/.*)?$'           # Optional path
        )
    
    def is_valid(self, url):
        """Check if URL is valid 🔍"""
        if not url or len(url) > 2048:  # URL length limit
            return False
        return bool(self.url_pattern.match(url))

# 🧪 Comprehensive test suite
@pytest.mark.parametrize("url,expected,test_id", [
    # Valid URLs ✅
    ("http://example.com", True, "basic_http"),
    ("https://example.com", True, "basic_https"),
    ("ftp://files.example.com", True, "ftp_protocol"),
    ("https://sub.domain.example.com", True, "subdomain"),
    ("https://example.com:8080", True, "with_port"),
    ("https://example.com/path/to/page", True, "with_path"),
    ("https://example.com/search?q=python", True, "with_query"),
    
    # Different TLDs 🌍
    ("https://example.org", True, "dot_org"),
    ("https://example.io", True, "dot_io"),
    ("https://example.co.uk", True, "country_tld"),
    
    # Invalid URLs ❌
    ("example.com", False, "missing_protocol"),
    ("http://", False, "missing_domain"),
    ("http://example", False, "missing_tld"),
    ("ht!tp://example.com", False, "invalid_protocol"),
    ("http://exam ple.com", False, "space_in_domain"),
    ("", False, "empty_string"),
    ("http://.com", False, "missing_domain_name"),
    
    # Edge cases 🎯
    ("http://localhost", False, "localhost_no_tld"),
    ("https://192.168.1.1", False, "ip_address"),
    ("http://a.b", True, "minimal_valid"),
    ("https://" + "a" * 2040 + ".com", False, "too_long"),
])
def test_url_validation(url, expected, test_id):
    """Test URL validation with multiple cases 🌐"""
    validator = URLValidator()
    result = validator.is_valid(url)
    assert result == expected, f"Failed for {test_id}: {url}"
    
    # 📊 Print test summary
    status = "✅ PASS" if result == expected else "❌ FAIL"
    print(f"{status} [{test_id}]: {url[:50]}...")

# 🎯 Separate test for extremely long URLs
@pytest.mark.parametrize("length", [100, 500, 1000, 2048, 2049])
def test_url_length_limits(length):
    """Test URL length boundaries 📏"""
    validator = URLValidator()
    base_url = "https://example.com/"
    padding = "a" * (length - len(base_url))
    test_url = base_url + padding
    
    expected = length <= 2048
    assert validator.is_valid(test_url) == expected

🎓 Key Takeaways

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

• ✅ Write parametrized tests that cover multiple scenarios 🎯
• ✅ Avoid code duplication in your test suites 🌵
• ✅ Use advanced features like indirect params and marks 🚀
• ✅ Test edge cases efficiently without repetition 🛡️
• ✅ Debug failed tests with clear test IDs 🐛

Remember: Good tests are the foundation of reliable software. Parametrization makes writing comprehensive tests a breeze! 🌬️

🤝 Next Steps

Congratulations! 🎉 You’ve mastered pytest parametrization!

Here’s what to do next:

1. 💻 Practice with the URL validator exercise
2. 🏗️ Refactor your existing tests to use parametrization
3. 📚 Explore pytest fixtures for even more power
4. 🌟 Share your parametrized tests with your team!

Remember: Every test you parametrize saves time and catches more bugs. Keep testing, keep learning, and most importantly, have fun! 🚀

Happy testing! 🎉🧪✨