# 未测试的代码
def calculate_total(price, quantity):
    return price * quantity

# 问题：没考虑负数、小数精度等

# 经过单元测试优化的代码
def calculate_total(price, quantity):
    if price < 0 or quantity < 0:
        raise ValueError("价格和数量不能为负数")

    # 使用 Decimal 避免浮点数精度问题
    from decimal import Decimal
    return Decimal(str(price)) * Decimal(str(quantity))

# 单元测试覆盖了：
# ✅ 正常情况
# ✅ 负数情况
# ✅ 小数精度问题

def test_user_login():
    """测试用户登录功能"""
    # 正常登录
    assert login("user@example.com", "password123") == True

    # 错误密码
    assert login("user@example.com", "wrong") == False

    # 不存在的用户
    assert login("nobody@example.com", "password") == False

# ❌ 重复代码
def test_add_positive():
    assert add(1, 2) == 3

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

# ✅ 参数化测试
@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (-1, -2, -3),
    (0, 0, 0),
    (100, 200, 300),
])
def test_add(a, b, expected):
    assert add(a, b) == expected

# 测试年龄验证函数
def test_validate_age():
    # 等价类：有效年龄
    assert validate_age(25) == True

    # 边界值：最小有效年龄
    assert validate_age(18) == True
    assert validate_age(17) == False

    # 边界值：最大有效年龄
    assert validate_age(120) == True
    assert validate_age(121) == False

    # 异常情况
    assert validate_age(-1) == False
    assert validate_age(0) == False

# ❌ 测试实现细节（脆弱）
def test_user_service():
    service = UserService()
    assert service.database.connection is not None
    assert service.cache.enabled == True

# ✅ 测试行为（稳定）
def test_user_service():
    service = UserService()
    user = service.get_user(123)
    assert user.name == "张三"

# 使用 Mock 避免依赖真实数据库
def test_get_user():
    mock_db = Mock()
    mock_db.query.return_value = {"id": 123, "name": "张三"}

    service = UserService(database=mock_db)
    user = service.get_user(123)

    assert user.name == "张三"

# 手动测试
def test_calculate_discount():
    # 测试人员手动运行并检查结果
    result = calculate_discount(price=100, discount=0.2)
    print(f"结果: {result}")  # 期望: 80

    # 手动验证是否正确
    if result == 80:
        print("✅ 测试通过")
    else:
        print("❌ 测试失败")

# 自动化测试（使用 pytest）
def test_calculate_discount():
    assert calculate_discount(100, 0.2) == 80
    assert calculate_discount(50, 0.1) == 45
    assert calculate_discount(200, 0.5) == 100

# 运行命令：pytest test_discount.py
# 输出：
# ✅ test_calculate_discount PASSED

# ❌ 慢测试（依赖真实数据库）
def test_get_user():
    db = connect_to_database()  # 耗时 2 秒
    user = db.query("SELECT * FROM users WHERE id=1")
    assert user.name == "张三"

# ✅ 快测试（使用 Mock）
def test_get_user():
    mock_db = Mock()
    mock_db.query.return_value = {"id": 1, "name": "张三"}
    user = get_user(1, database=mock_db)
    assert user.name == "张三"

# ❌ 有依赖的测试
def test_create_user():
    global user_id
    user_id = create_user("张三")

def test_update_user():
    # 依赖上一个测试的 user_id
    update_user(user_id, name="李四")

# ✅ 独立的测试
def test_create_user():
    user_id = create_user("张三")
    assert user_id is not None

def test_update_user():
    # 自己创建测试数据
    user_id = create_user("张三")
    result = update_user(user_id, name="李四")
    assert result == True

# ❌ 不可重复（依赖当前时间）
def test_is_weekend():
    assert is_weekend() == True  # 只有周末才通过

# ✅ 可重复（注入时间依赖）
def test_is_weekend():
    saturday = datetime(2024, 1, 6)  # 2024-01-06 是周六
    assert is_weekend(saturday) == True

    monday = datetime(2024, 1, 8)  # 2024-01-08 是周一
    assert is_weekend(monday) == False

# ❌ 需要人工判断
def test_calculate():
    result = calculate(10, 20)
    print(f"结果: {result}")  # 需要人工检查是否是 30

# ✅ 自动判断
def test_calculate():
    result = calculate(10, 20)
    assert result == 30  # 自动判断

# 单元测试：只测试 calculate_total 函数
def test_calculate_total():
    assert calculate_total(100, 2) == 200
    assert calculate_total(50, 3) == 150

# 集成测试：测试整个下单流程
def test_place_order():
    # 涉及多个模块：购物车、库存、支付
    cart = ShoppingCart()
    cart.add_item("商品A", 100, 2)

    order = place_order(cart)

    assert order.total == 200
    assert inventory.get_stock("商品A") == 98  # 库存减少
    assert payment.is_paid(order.id) == True  # 支付成功

# 测试登录功能（不关心内部如何验证）
def test_login():
    # 正确的用户名和密码
    assert login("user@example.com", "password123") == True

    # 错误的密码
    assert login("user@example.com", "wrong") == False

    # 不存在的用户
    assert login("nobody@example.com", "password") == False

def calculate_discount(price, vip_level):
    if price > 1000:
        if vip_level == "gold":
            return price * 0.7  # 路径 1
        else:
            return price * 0.8  # 路径 2
    else:
        if vip_level == "gold":
            return price * 0.9  # 路径 3
        else:
            return price  # 路径 4

# 白盒测试：覆盖所有 4 条路径
def test_calculate_discount():
    assert calculate_discount(1500, "gold") == 1050  # 路径 1
    assert calculate_discount(1500, "silver") == 1200  # 路径 2
    assert calculate_discount(500, "gold") == 450  # 路径 3
    assert calculate_discount(500, "silver") == 500  # 路径 4

# 已知风险：除零错误、空值、边界值
def test_calculate_average():
    # 正常情况
    assert calculate_average([1, 2, 3]) == 2

    # 风险 1：空列表（除零）
    with pytest.raises(ValueError):
        calculate_average([])

    # 风险 2：None 值
    with pytest.raises(TypeError):
        calculate_average(None)

    # 风险 3：边界值
    assert calculate_average([0]) == 0
    assert calculate_average([1000000]) == 1000000

# 安装
pip install pytest

# 编写测试（test_calculator.py）
def test_add():
    assert add(1, 2) == 3

def test_subtract():
    assert subtract(5, 3) == 2

# 运行测试
pytest test_calculator.py

# 业务代码
class ShoppingCart:
    def __init__(self):
        self.items = []

    def add_item(self, product_id, name, price, quantity):
        if price < 0:
            raise ValueError("价格不能为负数")
        if quantity <= 0:
            raise ValueError("数量必须大于 0")

        self.items.append({
            "product_id": product_id,
            "name": name,
            "price": price,
            "quantity": quantity
        })

    def get_total(self):
        return sum(item["price"] * item["quantity"] for item in self.items)

# 单元测试
def test_add_item_success():
    """测试正常添加商品"""
    cart = ShoppingCart()
    cart.add_item(1, "商品A", 100, 2)

    assert len(cart.items) == 1
    assert cart.get_total() == 200

def test_add_item_negative_price():
    """测试负数价格（应该抛出异常）"""
    cart = ShoppingCart()

    with pytest.raises(ValueError, match="价格不能为负数"):
        cart.add_item(1, "商品A", -100, 2)

def test_add_item_zero_quantity():
    """测试数量为 0（应该抛出异常）"""
    cart = ShoppingCart()

    with pytest.raises(ValueError, match="数量必须大于 0"):
        cart.add_item(1, "商品A", 100, 0)

def test_add_multiple_items():
    """测试添加多个商品"""
    cart = ShoppingCart()
    cart.add_item(1, "商品A", 100, 2)
    cart.add_item(2, "商品B", 50, 3)

    assert len(cart.items) == 2
    assert cart.get_total() == 350

# 业务代码
class UserService:
    def __init__(self, database):
        self.database = database

    def login(self, email, password):
        user = self.database.find_user_by_email(email)

        if user is None:
            return False

        if user.password != self.hash_password(password):
            return False

        return True

    def hash_password(self, password):
        # 简化示例，实际应使用 bcrypt 等
        return f"hashed_{password}"

# 单元测试（使用 Mock）
from unittest.mock import Mock

def test_login_success():
    """测试登录成功"""
    # 创建 Mock 数据库
    mock_db = Mock()
    mock_user = Mock()
    mock_user.password = "hashed_password123"
    mock_db.find_user_by_email.return_value = mock_user

    service = UserService(mock_db)
    result = service.login("user@example.com", "password123")

    assert result == True
    mock_db.find_user_by_email.assert_called_once_with("user@example.com")

def test_login_user_not_found():
    """测试用户不存在"""
    mock_db = Mock()
    mock_db.find_user_by_email.return_value = None

    service = UserService(mock_db)
    result = service.login("nobody@example.com", "password123")

    assert result == False

def test_login_wrong_password():
    """测试密码错误"""
    mock_db = Mock()
    mock_user = Mock()
    mock_user.password = "hashed_correct_password"
    mock_db.find_user_by_email.return_value = mock_user

    service = UserService(mock_db)
    result = service.login("user@example.com", "wrong_password")

    assert result == False

def test_user_service():
    service = UserService()
    # 测试内部实现细节
    assert service._database_connection is not None
    assert service._cache_enabled == True

def test_user_service():
    service = UserService()
    # 测试行为
    user = service.get_user(123)
    assert user.name == "张三"

user_id = None

def test_create_user():
    global user_id
    user_id = create_user("张三")

def test_delete_user():
    delete_user(user_id)  # 依赖上一个测试

def test_create_user():
    user_id = create_user("张三")
    assert user_id is not None

def test_delete_user():
    user_id = create_user("张三")  # 自己创建数据
    result = delete_user(user_id)
    assert result == True

def test_calculate_total():
    mock_add = Mock(return_value=5)
    mock_multiply = Mock(return_value=10)
    # 过度 Mock，测试失去意义

def test_calculate_discount():
    """
    ✅ 测试名称清晰
    ✅ 只测试一个功能点
    ✅ 快速（< 10ms）
    ✅ 独立（不依赖其他测试）
    ✅ 可重复（每次结果一致）
    """
    # Arrange（准备）
    price = 100
    discount_rate = 0.2

    # Act（执行）
    result = calculate_discount(price, discount_rate)

    # Assert（断言）
    assert result == 80