# 用户服务（返回 JSON）
def get_user(user_id):
    return {"id": user_id, "name": "张三", "age": 25}

# 订单服务（期望 User 对象）
def create_order(user):
    # ❌ 错误：期望 user.name，但收到的是字典
    order = Order(user_name=user.name)  # AttributeError

def test_create_order_integration():
    # 集成测试：真实调用用户服务
    user = get_user(123)

    # ❌ 测试失败：发现接口不匹配
    order = create_order(user)

# 购物车服务
def get_cart_items(user_id):
    return [
        {"product_id": 1, "quantity": 2, "price": 100.00},
        {"product_id": 2, "quantity": 1, "price": 50.50}
    ]

# 订单服务
def create_order_from_cart(user_id):
    items = get_cart_items(user_id)

    # ❌ 问题：price 是 float，数据库期望 Decimal
    # 可能导致精度丢失：100.00 → 99.99999999
    total = sum(item["price"] * item["quantity"] for item in items)

    return Order(total=total)

# 集成测试发现
def test_order_price_precision():
    order = create_order_from_cart(123)

    # ❌ 测试失败：期望 250.50，实际 250.49999999
    assert order.total == Decimal("250.50")

# 单元测试：只需 Mock
def test_create_order_unit():
    mock_inventory = Mock()
    mock_payment = Mock()

    order = create_order(mock_inventory, mock_payment)
    # 运行时间：10ms

# 集成测试：需要真实服务
def test_create_order_integration():
    # 启动数据库
    db = start_test_database()

    # 启动库存服务
    inventory_service = start_inventory_service(db)

    # 启动支付服务
    payment_service = start_payment_service(db)

    # 执行测试
    order = create_order(inventory_service, payment_service)

    # 运行时间：2-5 秒

# 集成测试失败
def test_place_order():
    order = place_order(user_id=123, product_id=456, quantity=2)

    # ❌ 测试失败：订单创建失败
    assert order is not None

# 问题可能在：
# 1. 用户服务：用户不存在？
# 2. 商品服务：商品不存在？
# 3. 库存服务：库存不足？
# 4. 支付服务：支付失败？
# 5. 订单服务：数据库错误？
# 6. 消息队列：消息丢失？

# 问题：用户服务返回 JSON，订单服务期望对象
# 解决方案 1：修改用户服务（影响所有调用方）
# 解决方案 2：修改订单服务（只影响订单服务）
# 解决方案 3：添加适配器层（最佳实践）

class UserAdapter:
    """适配器模式：转换用户服务的返回格式"""

    def __init__(self, user_service):
        self.user_service = user_service

    def get_user(self, user_id):
        # 调用用户服务（返回 JSON）
        user_data = self.user_service.get_user(user_id)

        # 转换为对象
        return User(**user_data)

# 步骤 1：测试模块 A
def test_module_a():
    result = module_a.process()
    assert result == expected

# 步骤 2：集成模块 A + B，测试接口
def test_module_a_b_integration():
    # 使用真实的模块 A
    result_a = module_a.process()

    # 使用真实的模块 B
    result_b = module_b.process(result_a)

    # 测试 A-B 接口
    assert result_b == expected

# 步骤 3：集成模块 B + C，测试接口
def test_module_b_c_integration():
    # 使用 Stub 模拟模块 A 的输出
    stub_a_output = {"data": "test"}

    # 使用真实的模块 B 和 C
    result_b = module_b.process(stub_a_output)
    result_c = module_c.process(result_b)

    # 测试 B-C 接口
    assert result_c == expected

# Stub（桩）：模拟被调用的模块
class PaymentServiceStub:
    """模拟支付服务（还未开发完成）"""

    def pay(self, amount):
        # 返回固定的成功响应
        return {"status": "success", "transaction_id": "12345"}

# Driver（驱动）：模拟调用方
class OrderServiceDriver:
    """模拟订单服务（用于测试支付服务）"""

    def test_payment(self):
        payment_service = PaymentService()

        # 驱动支付服务
        result = payment_service.pay(100)

        # 验证结果
        assert result["status"] == "success"

# 一次性测试所有模块
def test_all_modules_integration():
    # 启动所有模块
    module_a = ModuleA()
    module_b = ModuleB()
    module_c = ModuleC()
    module_d = ModuleD()

    # 执行完整流程
    result_a = module_a.process()
    result_b = module_b.process(result_a)
    result_c = module_c.process(result_b)
    result_d = module_d.process(result_c)

    # 验证最终结果
    assert result_d == expected

    # ❌ 如果测试失败，不知道是哪个模块的问题

# 第 1 步：测试 UI 层（使用 Stub）
class BusinessLogicStub:
    """模拟业务逻辑层"""
    def get_user_orders(self, user_id):
        return [{"id": 1, "total": 100}, {"id": 2, "total": 200}]

def test_ui_layer():
    ui = UILayer(business_logic=BusinessLogicStub())

    # 测试 UI 能否正确显示订单
    orders = ui.display_orders(user_id=123)
    assert len(orders) == 2

# 第 2 步：测试 UI + 业务逻辑层（使用 Stub）
class DatabaseStub:
    """模拟数据库层"""
    def query(self, sql):
        return [{"id": 1, "total": 100}, {"id": 2, "total": 200}]

def test_ui_business_integration():
    db_stub = DatabaseStub()
    business_logic = BusinessLogic(database=db_stub)
    ui = UILayer(business_logic=business_logic)

    # 测试 UI 和业务逻辑的集成
    orders = ui.display_orders(user_id=123)
    assert len(orders) == 2

# 第 3 步：测试完整系统（全部真实）
def test_full_system():
    db = RealDatabase()
    business_logic = BusinessLogic(database=db)
    ui = UILayer(business_logic=business_logic)

    # 测试完整流程
    orders = ui.display_orders(user_id=123)
    assert len(orders) > 0

# 第 1 步：测试数据库层（使用 Driver）
class DatabaseDriver:
    """驱动数据库层的测试"""
    def test_query(self):
        db = RealDatabase()

        # 驱动数据库查询
        result = db.query("SELECT * FROM orders WHERE user_id = 123")

        # 验证结果
        assert len(result) > 0

# 第 2 步：测试数据库 + 业务逻辑层（使用 Driver）
class BusinessLogicDriver:
    """驱动业务逻辑层的测试"""
    def test_get_user_orders(self):
        db = RealDatabase()
        business_logic = BusinessLogic(database=db)

        # 驱动业务逻辑
        orders = business_logic.get_user_orders(user_id=123)

        # 验证结果
        assert len(orders) > 0

# 第 3 步：测试完整系统（全部真实）
def test_full_system():
    db = RealDatabase()
    business_logic = BusinessLogic(database=db)
    ui = UILayer(business_logic=business_logic)

    # 测试完整流程
    orders = ui.display_orders(user_id=123)
    assert len(orders) > 0

# 顶层测试（自顶向下）
def test_top_down():
    business_stub = BusinessLogicStub()
    ui = UILayer(business_logic=business_stub)

    orders = ui.display_orders(user_id=123)
    assert len(orders) > 0

# 底层测试（自底向上）
def test_bottom_up():
    db = RealDatabase()
    business_logic = BusinessLogic(database=db)

    driver = BusinessLogicDriver()
    driver.test_get_user_orders(business_logic)

# 中间层测试（真实集成）
def test_middle_layer():
    db = RealDatabase()
    business_logic = BusinessLogic(database=db)
    ui = UILayer(business_logic=business_logic)

    # 测试完整流程
    orders = ui.display_orders(user_id=123)
    assert len(orders) > 0

# 用户服务
def get_user(user_id: int) -> dict:
    return {"id": user_id, "name": "张三"}

# 订单服务期望
def create_order(user: User):  # ❌ 期望 User 对象，实际收到 dict
    pass

# 集成测试发现问题
def test_interface_compatibility():
    user_data = get_user(123)

    # ❌ 测试失败：类型不匹配
    order = create_order(user_data)

# 购物车服务
def get_cart_total(user_id):
    return 100.50  # float

# 订单服务
def create_order(user_id):
    total = get_cart_total(user_id)

    # ❌ 问题：float 精度丢失
    # 100.50 → 100.49999999
    order = Order(total=total)

    return order

# 集成测试发现问题
def test_data_precision():
    order = create_order(123)

    # ❌ 测试失败：精度丢失
    assert order.total == Decimal("100.50")

# 支付服务
def pay(amount):
    if amount <= 0:
        raise ValueError("金额必须大于 0")

    # 调用第三方支付
    response = third_party_pay(amount)

    if response.status != "success":
        raise PaymentError(response.error_code)

# 订单服务
def create_order(amount):
    try:
        pay(amount)
    except PaymentError as e:
        # ✅ 正确处理支付异常
        return {"status": "failed", "error": str(e)}
    except Exception as e:
        # ❌ 问题：未处理 ValueError
        return {"status": "error"}

# 集成测试发现问题
def test_exception_handling():
    # ❌ 测试失败：ValueError 未被正确处理
    result = create_order(-100)
    assert result["status"] == "failed"

# 库存服务
def reduce_stock(product_id, quantity):
    stock = get_stock(product_id)

    # ❌ 问题：没有加锁，存在竞态条件
    if stock >= quantity:
        set_stock(product_id, stock - quantity)
        return True
    return False

# 集成测试发现问题
def test_concurrent_reduce_stock():
    # 初始库存：10
    set_stock(1, 10)

    # 并发执行 10 次，每次减 1
    with ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(reduce_stock, 1, 1) for _ in range(10)]
        results = [f.result() for f in futures]

    # ❌ 测试失败：库存应该是 0，实际可能是 2 或 3
    # 原因：竞态条件导致库存扣减不准确
    assert get_stock(1) == 0

def test_user_order_integration():
    """
    测试用例 ID: IT-001
    测试目标: 验证用户服务和订单服务的集成
    前置条件: 用户已注册，商品库存充足
    测试步骤:
      1. 调用用户服务获取用户信息
      2. 调用订单服务创建订单
      3. 验证订单中的用户信息正确
    预期结果: 订单创建成功，用户信息完整
    """
    # 步骤 1
    user = user_service.get_user(123)
    assert user is not None

    # 步骤 2
    order = order_service.create_order(
        user_id=user.id,
        product_id=456,
        quantity=2
    )

    # 步骤 3
    assert order.user_id == user.id
    assert order.user_name == user.name
    assert order.status == "created"

def test_place_order_integration():
    """
    测试用例 ID: IT-E001
    测试目标: 验证完整的下单流程
    涉及模块: 用户服务、商品服务、库存服务、订单服务
    """
    # 步骤 1：获取用户信息
    user = user_service.get_user(user_id=123)
    assert user is not None
    assert user.status == "active"

    # 步骤 2：获取商品信息
    product = product_service.get_product(product_id=456)
    assert product is not None
    assert product.price > 0

    # 步骤 3：检查库存
    stock = inventory_service.get_stock(product_id=456)
    assert stock >= 2

    # 步骤 4：创建订单
    order = order_service.create_order(
        user_id=user.id,
        product_id=product.id,
        quantity=2
    )

    # 步骤 5：验证结果
    assert order.status == "created"
    assert order.total == product.price * 2
    assert order.user_name == user.name

    # 步骤 6：验证库存扣减
    new_stock = inventory_service.get_stock(product_id=456)
    assert new_stock == stock - 2

def test_payment_integration():
    """
    测试用例 ID: IT-E002
    测试目标: 验证支付流程和通知
    涉及模块: 订单服务、支付服务、通知服务
    """
    # 步骤 1：创建订单
    order = order_service.create_order(
        user_id=123,
        product_id=456,
        quantity=1
    )
    assert order.status == "created"

    # 步骤 2：发起支付
    payment = payment_service.pay(
        order_id=order.id,
        amount=order.total,
        method="wechat"
    )
    assert payment.status == "success"

    # 步骤 3：验证订单状态更新
    updated_order = order_service.get_order(order.id)
    assert updated_order.status == "paid"
    assert updated_order.payment_id == payment.id

    # 步骤 4：验证通知发送
    notifications = notification_service.get_notifications(user_id=123)
    assert len(notifications) > 0
    assert "支付成功" in notifications[0].content

import requests

def test_microservices_integration():
    """
    测试用例 ID: IT-E003
    测试目标: 验证微服务间的 HTTP API 调用
    涉及服务: User API、Order API
    """
    # 步骤 1：调用 User API
    user_response = requests.get(
        "http://user-service:8001/api/users/123"
    )
    assert user_response.status_code == 200
    user_data = user_response.json()

    # 步骤 2：调用 Order API（内部会调用 User API）
    order_response = requests.post(
        "http://order-service:8002/api/orders",
        json={
            "user_id": 123,
            "product_id": 456,
            "quantity": 1
        }
    )
    assert order_response.status_code == 201
    order_data = order_response.json()

    # 步骤 3：验证数据一致性
    assert order_data["user_name"] == user_data["name"]
    assert order_data["user_email"] == user_data["email"]

# ❌ 错误：使用假数据
test_data = {
    "user_id": 1,
    "name": "test",
    "email": "test@test.com"
}

# ✅ 正确：使用真实场景的数据
test_data = {
    "user_id": 123456,
    "name": "张三",
    "email": "zhangsan@example.com",
    "phone": "13800138000",
    "address": "北京市朝阳区xxx街道xxx号"
}

import logging

def test_integration():
    logging.info("开始测试用户服务和订单服务的集成")

    # 步骤 1
    logging.info("步骤 1：获取用户信息")
    user = user_service.get_user(123)
    logging.info(f"用户信息：{user}")

    # 步骤 2
    logging.info("步骤 2：创建订单")
    order = order_service.create_order(user.id, 456, 1)
    logging.info(f"订单信息：{order}")

    # 验证
    assert order.user_id == user.id, \
        f"用户 ID 不匹配：期望 {user.id}，实际 {order.user_id}"

# pytest + requests
import pytest
import requests

def test_api_integration():
    # 调用 API
    response = requests.get("http://localhost:8000/api/users/123")

    # 验证结果
    assert response.status_code == 200
    assert response.json()["name"] == "张三"