测试重构实战：识别和修复测试代码坏味道，性能提升较高

# 坏味道示例：测试与实现细节过度耦合
def test_user_creation():
    # 直接调用内部方法，而不是公共接口
    result = UserService._generate_user_id("test@example.com")
    assert result == "user_test@example.com_abc123"

# 坏味道示例：重复的测试逻辑
def test_order_with_discount():
    user = User("test_user", "test@email.com")
    product = Product("book", 100)
    order = Order(user, product)
    order.apply_discount(10)
    assert order.total_price == 90

def test_order_without_discount():
    user = User("test_user", "test@email.com")
    product = Product("book", 100)
    order = Order(user, product)
    assert order.total_price == 100

# 坏味道示例：模糊的断言
def test_user_login():
    result = login_service.login("admin", "password123")
    assert result is not None  # 断言过于模糊

# 重构后：提取setup方法
import unittest

class TestOrder(unittest.TestCase):
    def setUp(self):
        self.user = User("test_user", "test@email.com")
        self.product = Product("book", 100)
        self.order = Order(self.user, self.product)
    
    def test_order_with_discount(self):
        self.order.apply_discount(10)
        assert self.order.total_price == 90
    
    def test_order_without_discount(self):
        assert self.order.total_price == 100

# 使用Factory模式创建测试数据
class OrderFactory:
    @staticmethod
    def create(user=None, product=None, discount=0):
        user = user or User("default_user", "default@email.com")
        product = product or Product("default_product", 50)
        order = Order(user, product)
        if discount > 0:
            order.apply_discount(discount)
        return order

def test_complex_order_scenario():
    vip_user = User("vip_user", "vip@email.com", level="VIP")
    expensive_product = Product("laptop", 2000)
    order = OrderFactory.create(user=vip_user, product=expensive_product, discount=20)
    assert order.total_price == 1600

# 重构后：强化断言
class OrderAssertions:
    @staticmethod
    def assert_order_total(order, expected_total):
        assert order.total_price == expected_total, \
            f"Expected total {expected_total}, but got {order.total_price}"

def test_order_with_vip_discount():
    order = OrderFactory.create(discount=30)
    OrderAssertions.assert_order_total(order, 35)  # 50 * 0.7 = 35

pip install sentry-sdk

import sentry_sdk
from sentry_sdk.integrations.pytest import PytestIntegration

sentry_sdk.init(
    dsn="https://your-test-dsn@sentry.io/123456",
    integrations=[PytestIntegration()],
    traces_sample_rate=1.0,  # 100%采样率，测试环境可接受
    environment="testing"
)

import sentry_sdk
from sentry_sdk import start_transaction

def test_heavy_computation():
    with start_transaction(op="test", name="test_heavy_computation"):
        # 模拟复杂计算
        result = heavy_computation_function(1000)
        assert result == 500500

# Sentry 警报规则配置示例
rules:
  - name: "Test Performance Degradation"
    conditions:
      - metric: "duration"
        operator: ">"
        value: "avg_duration * 2"
    actions:
      - type: "slack"
        channel: "#test-monitoring"

class TestPaymentProcess(unittest.TestCase):
    def test_successful_payment(self):
        user = User("test", "test@test.com")
        payment = Payment(user, 100)
        payment.process()
        assert payment.status == "success"
    
    def test_failed_payment_insufficient_balance(self):
        user = User("test", "test@test.com")
        payment = Payment(user, 10000)  # 余额不足
        payment.process()
        assert payment.status == "failed"
    
    def test_failed_payment_network_error(self):
        user = User("test", "test@test.com")
        payment = Payment(user, 100)
        # 模拟网络错误
        payment._network_client = MockNetworkClient(raise_error=True)
        payment.process()
        assert payment.status == "failed"

import sentry_sdk
from sentry_sdk import start_transaction
from unittest.mock import patch

class TestPaymentProcess(unittest.TestCase):
    def setUp(self):
        self.user = User("test", "test@test.com")
        self.payment = Payment(self.user, 100)
    
    def test_successful_payment(self):
        with start_transaction(op="test", name="test_successful_payment"):
            self.payment.process()
            assert self.payment.status == "success"
            assert self.payment.transaction_id is not None
    
    def test_failed_payment_insufficient_balance(self):
        with start_transaction(op="test", name="test_insufficient_balance"):
            payment = Payment(self.user, 10000)
            payment.process()
            assert payment.status == "failed"
            assert payment.error_code == "INSUFFICIENT_BALANCE"
    
    @patch('payment_module.Payment._network_client')
    def test_failed_payment_network_error(self, mock_client):
        mock_client.process_payment.side_effect = NetworkError("Connection timeout")
        self.payment.process()
        assert self.payment.status == "failed"
        assert self.payment.error_code == "NETWORK_ERROR"