单元测试深度实践：pytest / JUnit 5 / Go testing 横评与生产级模式

Arrange ──► Act ──► Assert
准备数据    执行操作    验证结果

# Python 示例（pytest）:
def test_calculate_total_with_discount():
    # Arrange
    cart = ShoppingCart()
    cart.add_item(Item("book", price=100, quantity=2))
    cart.add_item(Item("pen", price=10, quantity=3))
    coupon = Coupon(code="SAVE10", discount_percent=10)

    # Act
    total = cart.calculate_total(coupon)

    # Assert
    # 100*2 + 10*3 = 230, 打9折 = 207
    assert total == 207

// Java 示例（JUnit 5）:
@Test
@DisplayName("计算订单总额应正确应用折扣")
void calculateTotalWithDiscount() {
    // Arrange
    ShoppingCart cart = new ShoppingCart();
    cart.addItem(new Item("book", 100, 2));
    cart.addItem(new Item("pen", 10, 3));
    Coupon coupon = new Coupon("SAVE10", 10);

    // Act
    int total = cart.calculateTotal(coupon);

    // Assert
    assertEquals(207, total);
}

// Go 示例:
func TestCalculateTotalWithDiscount(t *testing.T) {
    // Arrange
    cart := NewShoppingCart()
    cart.AddItem(Item{Name: "book", Price: 100, Quantity: 2})
    cart.AddItem(Item{Name: "pen", Price: 10, Quantity: 3})
    coupon := Coupon{Code: "SAVE10", DiscountPercent: 10}

    // Act
    total := cart.CalculateTotal(coupon)

    // Assert
    if total != 207 {
        t.Errorf("expected 207, got %d", total)
    }
}

# conftest.py —— pytest 自动发现的共享 fixture
import pytest

@pytest.fixture(scope="function")  # 每次测试新建一次
def empty_cart():
    cart = ShoppingCart()
    yield cart
    # 清理：fixture 自动 teardown

@pytest.fixture(scope="session")   # 整个测试会话只创建一次
def redis_client():
    import redis
    client = redis.Redis(host="localhost", port=6379, db=1)
    yield client
    client.flushdb()  # 测试结束后清空

@pytest.fixture
def sample_order():
    return Order(
        id="ORD-001",
        items=[Item("laptop", 9999, 1)],
        customer_id="CUST-42",
        status="pending"
    )

# 测试中使用
def test_order_total(sample_order):
    assert sample_order.total == 9999

# fixture 互相依赖
@pytest.fixture
def paid_order(sample_order):
    sample_order.pay()
    return sample_order

def test_paid_order_status(paid_order):
    assert paid_order.status == "paid"

import pytest
from calculator import is_prime

@pytest.mark.parametrize(
    "n,expected",
    [
        (2, True),
        (3, True),
        (4, False),
        (17, True),
        (18, False),
        (97, True),
        (1, False),       # 边界
        (0, False),       # 边界
        (-5, False),      # 负数
        (2147483647, True),  # 大质数（int32 最大值是质数）
    ],
    ids=["prime_2", "prime_3", "not_prime_4", "prime_17",
         "not_prime_18", "prime_97", "edge_1", "edge_0",
         "negative", "large_prime"]  # 自定义测试名
)
def test_is_prime(n, expected):
    assert is_prime(n) == expected

def test_time_sensitive_logic(monkeypatch):
    # 冻结时间，摆脱时间依赖
    class FakeDatetime:
        @classmethod
        def now(cls):
            return datetime(2024, 1, 15, 10, 30, 0)

    monkeypatch.setattr("mymodule.datetime", FakeDatetime)
    result = mymodule.is_business_hours()
    assert result is True  # 周一 10:30 是工作时间

pytest --cov=src --cov-report=term-missing --cov-report=html tests/

# pytest.ini —— 覆盖率阈值
[pytest]
addopts = --cov=src --cov-report=term --cov-report=html
          --cov-fail-under=80

JUnit Platform ──► 在 JVM 上启动测试框架的基础
       │
       ├── JUnit Jupiter ──► JUnit 5 新编程和扩展模型
       │
       └── JUnit Vintage ──► 向后兼容 JUnit 3/4

// 基本测试
@Test
@DisplayName("订单金额超过 1000 应触发会员升级")
void shouldUpgradeMemberWhenOrderExceeds1000() { }

// 禁用与条件
@Disabled("等待优惠券系统上线后再启用")
@Test
void disabledTest() { }

@EnabledOnOs(OS.MAC)          // 只在 macOS 运行
@Test
void macOnly() { }

@EnabledIfSystemProperty(named = "env", matches = "ci")
@Test
void ciOnly() { }

// 超时
@Test
@Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
void shouldCompleteWithin500ms() { }

// 重复
@RepeatedTest(5)
void repeatedTest() { }

// 嵌套组织
@DisplayName("购物车服务")
class ShoppingCartTest {
    @Nested
    @DisplayName("当购物车为空时")
    class WhenEmpty {
        @Test @DisplayName("计算总额应返回 0")
        void totalIsZero() { assertEquals(0, cart.total()); }

        @Test @DisplayName("添加商品后不应为空")
        void notEmptyAfterAdd() { }
    }

    @Nested
    @DisplayName("当购物车有商品时")
    class WhenHasItems {
        @Test @DisplayName("计算总额应累加所有商品")
        void totalIsSum() { }
    }
}

@ParameterizedTest
@ValueSource(strings = {"hello", "racecar", "world"})
@DisplayName("回文检测应正确判断")
void isPalindrome(String candidate) {
    assertTrue(StringUtils.isPalindrome(candidate));
}

@ParameterizedTest
@CsvSource({
    "1, 1, 2",      // a + b = expected
    "2, 3, 5",
    "10, 20, 30",
    "-1, 1, 0",
    "0, 0, 0"
})
@DisplayName("加法运算应正确")
void add(int a, int b, int expected) {
    assertEquals(expected, calculator.add(a, b));
}

@ParameterizedTest
@MethodSource("provideEmailTestCases")
@DisplayName("邮箱格式校验")
void isValidEmail(String email, boolean expected) {
    assertEquals(expected, validator.isValidEmail(email));
}

static Stream<Arguments> provideEmailTestCases() {
    return Stream.of(
        Arguments.of("test@example.com", true),
        Arguments.of("invalid.email", false),
        Arguments.of("", false),
        Arguments.of("user@domain.co.uk", true),
        Arguments.of("a@b.c", true)
    );
}

// 自定义扩展：自动重置数据库
public class DatabaseResetExtension implements BeforeEachCallback, AfterEachCallback {
    @Override
    public void beforeEach(ExtensionContext context) {
        TestDataUtils.resetSequences();
    }

    @Override
    public void afterEach(ExtensionContext context) {
        TestDataUtils.truncateAllTables();
    }
}

// 使用扩展
@ExtendWith(DatabaseResetExtension.class)
class OrderServiceTest { }

@ParameterizedTest
@CsvSource({"2024-01-15, true", "2024-12-25, false"})  // 工作日 vs 假日
void isBusinessDay(
    @ConvertWith(LocalDateConverter.class) LocalDate date,
    boolean expected
) {
    assertEquals(expected, BusinessCalendar.isBusinessDay(date));
}

static class LocalDateConverter extends SimpleArgumentConverter {
    @Override
    protected Object convert(Object source, Class<?> targetType) {
        return LocalDate.parse(source.toString());
    }
}

package calculator

import (
    "testing"
    "math"
)

// Table-Driven Test — Go 最经典的测试模式
func TestIsPrime(t *testing.T) {
    tests := []struct {
        name     string
        input    int
        expected bool
    }{
        {"prime_2", 2, true},
        {"prime_3", 3, true},
        {"not_prime_4", 4, false},
        {"prime_17", 17, true},
        {"not_prime_18", 18, false},
        {"edge_1", 1, false},
        {"edge_0", 0, false},
        {"negative", -5, false},
        {"large_prime", 2147483647, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := IsPrime(tt.input)
            if got != tt.expected {
                t.Errorf("IsPrime(%d) = %v, want %v",
                    tt.input, got, tt.expected)
            }
        })
    }
}

func TestUserService(t *testing.T) {
    svc := NewUserService(testDB)

    t.Run("Create", func(t *testing.T) {
        user, err := svc.Create("alice", "alice@example.com")
        if err != nil {
            t.Fatal(err)  // 子测试失败不影响其他子测试
        }
        if user.ID == "" {
            t.Error("expected non-empty ID")
        }
    })

    t.Run("GetByID", func(t *testing.T) {
        user, err := svc.GetByID("test-id-1")
        if err != nil {
            t.Skip("依赖 Create 测试的数据")  // 跳过而非失败
        }
        _ = user
    })
}

// 测试 Fibonacci 算法性能
func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

// 带不同参数的 Benchmark
func BenchmarkFibonacciSizes(b *testing.B) {
    sizes := []int{10, 20, 30}
    for _, n := range sizes {
        b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                Fibonacci(n)
            }
        })
    }
}

// 对比两个实现的 Benchmark
func BenchmarkFibRecursive(b *testing.B) {
    for i := 0; i < b.N; i++ {
        FibRecursive(25)
    }
}

func BenchmarkFibIterative(b *testing.B) {
    for i := 0; i < b.N; i++ {
        FibIterative(25)
    }
}

$ go test -bench=. -benchmem
BenchmarkFibRecursive-8     48921    24510 ns/op    0 B/op    0 allocs/op
BenchmarkFibIterative-8  10000000      105 ns/op    0 B/op    0 allocs/op

import "github.com/stretchr/testify/assert"
import "github.com/stretchr/testify/mock"

func TestDivide(t *testing.T) {
    result, err := Divide(10, 2)
    assert.NoError(t, err)
    assert.Equal(t, 5.0, result)

    _, err = Divide(10, 0)
    assert.Error(t, err)
    assert.Contains(t, err.Error(), "division by zero")
}

// testify/mock
 type MockPaymentGateway struct {
    mock.Mock
}

func (m *MockPaymentGateway) Charge(amount float64, cardToken string) (string, error) {
    args := m.Called(amount, cardToken)
    return args.String(0), args.Error(1)
}

func TestCheckoutService(t *testing.T) {
    gateway := new(MockPaymentGateway)
    svc := NewCheckoutService(gateway)

    gateway.On("Charge", 100.0, "tok_visa").
        Return("ch_123", nil).Once()

    chargeID, err := svc.ProcessPayment(100.0, "tok_visa")
    assert.NoError(t, err)
    assert.Equal(t, "ch_123", chargeID)

    gateway.AssertExpectations(t)
}

被测代码            测试替身              真实依赖
────────       ────────────────       ─────────
  UserService  ──► EmailSenderStub        SMTP Server
               │  （始终返回 OK）          （慢/不确定）
               │
               ├── EmailSenderFake         SMTP Server
               │   （内存队列）             （慢/不确定）
               │
               └── EmailSenderMock         SMTP Server
                   （验证调用参数）          （慢/不确定）

# ❌ 错误：直接 mock requests 库
def test_user_service_bad():
    with patch("requests.get") as mock_get:
        mock_get.return_value.json.return_value = {"name": "Alice"}
        user = fetch_user("123")  # 直接依赖 requests
        assert user.name == "Alice"

# ✅ 正确：mock 自己的抽象层（repository 接口）
class UserRepository:
    def get_by_id(self, user_id: str) -> User:
        ...

class HttpUserRepository(UserRepository):
    def get_by_id(self, user_id: str) -> User:
        resp = requests.get(f"/users/{user_id}")
        return User(**resp.json())

# 测试中 mock 接口
def test_user_service_good():
    mock_repo = Mock(spec=UserRepository)
    mock_repo.get_by_id.return_value = User(name="Alice")
    svc = UserService(mock_repo)
    user = svc.get_user("123")
    assert user.name == "Alice"

太细                    刚好                     太粗
─────                ──────────              ─────────
只测 getter          一个业务操作              整个用户注册流程
(无价值)             (一个用例 = 一个测试)     (覆盖多个逻辑分支)

// ❌ 紧耦合：难以测试
type UserService struct {
    db *sql.DB  // 直接依赖，无法替换
}

// ✅ 解耦：通过 interface 注入
type UserRepository interface {
    FindByID(id string) (*User, error)
    Save(u *User) error
}

type UserService struct {
    repo UserRepository  // 依赖接口而非实现
}

// ❌ 错误：通过反射测私有方法（brittle！）
@Test
void testPrivateMethod() throws Exception {
    Method m = Service.class.getDeclaredMethod("validateEmail", String.class);
    m.setAccessible(true);
    boolean result = (boolean) m.invoke(service, "test@example.com");
    assertTrue(result);
}

// ✅ 正确：私有方法的逻辑通过公共方法间接验证
// 如果私有方法逻辑复杂到需要单独测试，说明它应该成为一个独立的类

// ❌ 毫无意义：测试 JavaBean getter/setter
@Test
void testSetAndGetName() {
    User user = new User();
    user.setName("Alice");
    assertEquals("Alice", user.getName());
}
// 如果你的 getter/setter 有 complex 逻辑，那它不是真正的 getter/setter

// ❌ 过度 Mock：测试里全是 mock，测了个寂寞
@Test
void testOrderProcessing() {
    when(mockRepo.findById(any())).thenReturn(mockOrder);
    when(mockOrder.getItems()).thenReturn(List.of(mockItem));
    when(mockItem.getPrice()).thenReturn(100);
    when(mockCalculator.calculate(any())).thenReturn(100);
    when(mockPayment.charge(any())).thenReturn(true);
    // ... 测了 5 个 mock 的交互，没测真正逻辑
}

// ✅ 合理 Mock：只 mock 外部边界
@Test
void testOrderProcessing() {
    // 真实 Order + 真实计算逻辑
    Order order = new Order(List.of(new Item("laptop", 100, 1)));

    when(paymentGateway.charge(100, "tok_123")).thenReturn("ch_456");

    String chargeId = service.process(order, "tok_123");
    assertEquals("ch_456", chargeId);
}

# ❌ 看不懂 200 和 600 为什么是这个结果
def test_calc():
    assert calculate(100, 200) == 600  # 为什么？

# ✅ 命名变量，让测试文档化行为
def test_calc_with_discount():
    base_price = 100
    quantity = 2
    discount = 0.1  # 10% 折扣

    result = calculate(base_price, quantity, discount)

    expected = 180  # 100 * 2 * (1 - 0.1)
    assert result == expected