python | Python单元测试的参数化与数据驱动测试

本文来源公众号“python”，仅用于学术分享，侵权删，干货满满。

原文链接：Python单元测试的参数化与数据驱动测试

软件测试是保障代码质量的重要环节，而单元测试作为测试金字塔的基础，对于捕获低级别的错误至关重要。在Python开发中，随着应用复杂度的提高，传统的单元测试方法往往显得繁琐且难以维护。参数化测试和数据驱动测试作为单元测试的高级技术，能够大幅提升测试效率和代码覆盖率。本文将深入探讨这两种测试技术的实现方法和最佳实践。

参数化测试的基本概念

参数化测试是指使用不同参数集来重复执行相同的测试逻辑。这种方法可以有效测试函数在各种输入情况下的行为，而无需为每种情况编写单独的测试方法。在Python中，主流的测试框架如pytest和unittest都提供了参数化测试的支持。

以下是一个简单的计算函数，我们将使用它来演示参数化测试的实现：

def calculate_discount(price, discount_percentage):
    """
    计算折扣后的价格
    
    Args:
        price: 原始价格
        discount_percentage: 折扣百分比（0-100）
        
    Returns:
        折扣后的价格
    
    Raises:
        ValueError: 如果折扣百分比超出范围
    """
    if not 0 <= discount_percentage <= 100:
        raise ValueError("折扣百分比必须在0到100之间")
    
    discount = price * (discount_percentage / 100)
    return price - discount

这个函数接受一个价格和折扣百分比，计算折扣后的价格。我们需要测试不同价格和折扣组合下函数的行为，以及异常情况的处理。

使用pytest实现参数化测试

pytest是Python中最受欢迎的测试框架之一，它提供了强大而简洁的@pytest.mark.parametrize装饰器来实现参数化测试。

首先，需要安装pytest：

# 在命令行中执行
# pip install pytest

接下来，使用pytest的参数化特性来测试calculate_discount函数：

import pytest

def test_calculate_discount():
    # 非参数化测试示例
    assert calculate_discount(100, 10) == 90
    assert calculate_discount(200, 20) == 160
    assert calculate_discount(100, 0) == 100
    assert calculate_discount(100, 100) == 0

# 使用pytest参数化测试
@pytest.mark.parametrize("price, discount, expected", [
    (100, 10, 90),
    (200, 20, 160),
    (100, 0, 100),
    (100, 100, 0),
    (50, 50, 25),
])
def test_calculate_discount_parameterized(price, discount, expected):
    assert calculate_discount(price, discount) == expected

# 测试异常情况
@pytest.mark.parametrize("price, discount", [
    (100, -10),
    (100, 110),
])
def test_calculate_discount_raises(price, discount):
    with pytest.raises(ValueError):
        calculate_discount(price, discount)

在上面的代码中，展示了一个不使用参数化的测试方法，使用@pytest.mark.parametrize实现了两个参数化测试：一个测试正常情况，一个测试异常情况。每组测试数据将被依次传入测试函数，创建单独的测试用例。

执行这些测试会产生以下结果：

collected 7 items

test_discount.py::test_calculate_discount PASSED
test_discount.py::test_calculate_discount_parameterized[100-10-90] PASSED
test_discount.py::test_calculate_discount_parameterized[200-20-160] PASSED
test_discount.py::test_calculate_discount_parameterized[100-0-100] PASSED
test_discount.py::test_calculate_discount_parameterized[100-100-0] PASSED
test_discount.py::test_calculate_discount_parameterized[50-50-25] PASSED
test_discount.py::test_calculate_discount_raises[100--10] PASSED
test_discount.py::test_calculate_discount_raises[100-110] PASSED

注意pytest如何为每个参数组合创建单独的测试用例，并在测试名称中包含参数值，这使得在测试失败时能够快速定位问题。

使用unittest实现参数化测试

Python的标准库unittest也可以实现参数化测试，但需要借助subTest上下文管理器或第三方库如parameterized。

以下是使用unittest内置的subTest实现参数化测试的示例：

import unittest

class TestCalculateDiscount(unittest.TestCase):
    def test_calculate_discount(self):
        # 测试数据
        test_cases = [
            {"price": 100, "discount": 10, "expected": 90},
            {"price": 200, "discount": 20, "expected": 160},
            {"price": 100, "discount": 0, "expected": 100},
            {"price": 100, "discount": 100, "expected": 0},
            {"price": 50, "discount": 50, "expected": 25},
        ]
        
        # 使用subTest进行参数化测试
        for tc in test_cases:
            with self.subTest(price=tc["price"], discount=tc["discount"]):
                result = calculate_discount(tc["price"], tc["discount"])
                self.assertEqual(result, tc["expected"])
    
    def test_calculate_discount_raises(self):
        # 测试异常情况
        invalid_inputs = [
            {"price": 100, "discount": -10},
            {"price": 100, "discount": 110},
        ]
        
        for tc in invalid_inputs:
            with self.subTest(price=tc["price"], discount=tc["discount"]):
                with self.assertRaises(ValueError):
                    calculate_discount(tc["price"], tc["discount"])

if __name__ == "__main__":
    unittest.main()

subTest方法的优势在于它允许在一个测试方法中执行多个相关的测试案例，且如果其中一个子测试失败，其他子测试仍会继续执行。这使得开发者可以在一次测试运行中发现多个问题。

数据驱动测试

数据驱动测试是参数化测试的一种扩展，它强调将测试数据与测试代码完全分离。测试数据可以来自外部文件（如CSV、JSON、YAML）、数据库或API，而不是硬编码在测试代码中。

以下是一个使用CSV文件作为数据源的数据驱动测试示例：

import csv
import pytest

def load_test_data(file_path):
    """从CSV文件加载测试数据"""
    test_data = []
    with open(file_path, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            # 转换字符串为适当的类型
            price = float(row['price'])
            discount = float(row['discount'])
            expected = float(row['expected'])
            test_data.append((price, discount, expected))
    return test_data

@pytest.mark.parametrize("price, discount, expected", load_test_data('discount_test_data.csv'))
def test_calculate_discount_from_csv(price, discount, expected):
    assert calculate_discount(price, discount) == expected

假设我们有一个名为discount_test_data.csv的CSV文件，其内容如下：

price,discount,expected
100,10,90
200,20,160
100,0,100
100,100,0
50,50,25

执行测试时，pytest会从CSV文件加载数据并为每行创建一个测试用例。这种方法特别适合需要大量测试数据的场景，如边界值测试或者回归测试。

参数化测试的高级技巧

1. 组合多个参数化装饰器

当需要测试多个参数的不同组合时，可以使用多个parametrize装饰器。这将创建这些参数的笛卡尔积：

@pytest.mark.parametrize("price", [50, 100, 200])
@pytest.mark.parametrize("discount", [0, 10, 50, 100])
def test_calculate_discount_matrix(price, discount):
    result = calculate_discount(price, discount)
    expected = price - (price * discount / 100)
    assert result == expected

这段代码将创建3×4=12个测试用例，测试所有价格和折扣的组合。

2. 使用id为测试用例命名

默认情况下，pytest使用参数值作为测试用例的标识符。但对于复杂的参数，可以使用ids参数提供更有意义的名称：

@pytest.mark.parametrize(
    "price, discount, expected",
    [
        (100, 10, 90),
        (200, 20, 160),
        (100, 0, 100),
        (100, 100, 0),
    ],
    ids=["10%_off", "20%_off", "no_discount", "full_discount"]
)
def test_calculate_discount_with_ids(price, discount, expected):
    assert calculate_discount(price, discount) == expected

这将使测试报告更易读，特别是在测试失败时能更快速地定位问题。

3. 参数化测试类

除了参数化单个测试方法外，还可以参数化整个测试类，使类中的所有测试方法都使用指定的参数：

@pytest.mark.parametrize("price, discount_factor", [(100, 0.1), (200, 0.2)])
class TestDiscountClass:
    def test_calculate_net_price(self, price, discount_factor):
        discount_percentage = discount_factor * 100
        expected = price * (1 - discount_factor)
        assert calculate_discount(price, discount_percentage) == expected
    
    def test_calculate_discount_amount(self, price, discount_factor):
        discount_percentage = discount_factor * 100
        expected_discount = price * discount_factor
        result = price - calculate_discount(price, discount_percentage)
        assert result == expected_discount

这种方法特别适合当多个测试方法需要共享相同的测试数据时。

使用pytest-parametrization插件

对于更复杂的参数化需求，pytest生态系统提供了多种插件，如pytest-parametrization：

# 安装插件
# pip install pytest-parametrization

from pytest_parametrization import CaseParams, parametrize

# 定义测试用例
discount_cases = [
    CaseParams(price=100, discount=10, expected=90, id="10%_off"),
    CaseParams(price=200, discount=20, expected=160, id="20%_off"),
    CaseParams(price=100, discount=0, expected=100, id="no_discount"),
    CaseParams(price=100, discount=100, expected=0, id="full_discount"),
]

@parametrize(cases=discount_cases)
def test_calculate_discount_with_plugin(price, discount, expected):
    assert calculate_discount(price, discount) == expected

这种方法提供了更强大和灵活的参数化能力，特别是对于复杂的测试场景。

实践应用：测试Web API

参数化测试也广泛应用于Web API测试。以下是一个使用requests库和pytest测试REST API的示例：

import requests
import pytest

# 假设我们的API用于创建用户
def create_user(username, email, age):
    response = requests.post(
        "https://api.example.com/users",
        json={"username": username, "email": email, "age": age}
    )
    return response

# 测试数据
test_users = [
    # 有效用户
    {"username": "user1", "email": "user1@example.com", "age": 25, "expected_status": 201},
    {"username": "user2", "email": "user2@example.com", "age": 30, "expected_status": 201},
    # 无效用户（年龄太小）
    {"username": "minor", "email": "minor@example.com", "age": 17, "expected_status": 400},
    # 无效用户（邮箱格式不正确）
    {"username": "bademail", "email": "not-an-email", "age": 25, "expected_status": 400},
]

@pytest.mark.parametrize("user_data", test_users)
def test_create_user(user_data):
    response = create_user(
        user_data["username"],
        user_data["email"],
        user_data["age"]
    )
    assert response.status_code == user_data["expected_status"]
    
    # 对于成功创建的用户，验证响应内容
    if user_data["expected_status"] == 201:
        user = response.json()
        assert user["username"] == user_data["username"]
        assert user["email"] == user_data["email"]
        assert user["age"] == user_data["age"]

这个示例展示了如何使用参数化测试来测试API在不同输入下的行为，包括边界情况和错误处理。

数据驱动测试的最佳实践

1. 使用合适的数据格式

根据测试数据的复杂度选择合适的数据格式：

• CSV：适合简单的表格数据

• JSON/YAML：适合结构化或嵌套的数据

• 数据库：适合大量或关系型数据

2. 数据准备和清理

在测试执行前后正确准备和清理测试数据，特别是在与外部系统交互时：

@pytest.fixture
def test_database():
    # 设置测试数据库
    db = setup_test_database()
    yield db
    # 清理测试数据
    db.cleanup()

def test_with_database(test_database):
    # 使用测试数据库进行测试
    pass

3. 错误处理和报告

确保测试代码能够处理数据加载错误，并提供清晰的错误信息：

def load_test_data(file_path):
    try:
        with open(file_path, 'r') as f:
            # 加载数据
            return parse_data(f)
    except FileNotFoundError:
        pytest.fail(f"测试数据文件不存在: {file_path}")
    except json.JSONDecodeError:
        pytest.fail(f"测试数据文件格式不正确: {file_path}")

总结

参数化测试和数据驱动测试是提升Python单元测试效率和覆盖率的强大技术。通过将测试逻辑与测试数据分离，这些方法使测试代码更加简洁、可维护，同时能够更全面地验证代码在各种情况下的行为。在实际应用中，选择合适的测试框架和数据源格式，结合项目的具体需求，能够构建出高效且可靠的测试套件。无论是简单的函数测试还是复杂的API测试，参数化测试都能提供显著的价值。

THE END !

文章结束，感谢阅读。您的点赞，收藏，评论是我继续更新的动力。大家有推荐的公众号可以评论区留言，共同学习，一起进步。