3、Go测试框架概览：testing包基础、表驱动测试、子测试与并行测试

在Go微服务开发中，测试是保障通信隔离与Mock正确性的第一道防线。Go语言内置的testing包提供了轻量但强大的测试原语，配合表驱动测试、子测试与并行测试，能够高效覆盖Mock隔离场景下的各种边界条件。本章系统梳理这些核心机制，为后续Mock调试打下坚实基础。

3.1 testing包基础：测试函数与运行约定

Go的测试函数必须遵循以下约定：

• 文件名以 _test.go 结尾，例如 mock_test.go
• 测试函数签名：func TestXxx(t *testing.T)
• 使用 t.Error / t.Errorf 报告失败（不终止当前测试）
• 使用 t.Fatal / t.Fatalf 报告失败并立即终止当前测试
• 使用 t.Log / t.Logf 输出调试信息（仅 -v 时显示）

// 基础测试示例：验证Mock服务的响应
func TestMockService_GetUser(t *testing.T) {
    mockSvc := NewMockUserService()
    user, err := mockSvc.GetUser("u-001")
    if err != nil {
        t.Fatalf("Mock GetUser failed: %v", err) // 初始化失败，立即终止
    }
    if user.ID != "u-001" {
        t.Errorf("expected user ID 'u-001', got '%s'", user.ID) // 断言失败，继续执行
    }
    if user.Name == "" {
        t.Error("user name should not be empty")
    }
}

3.2 表驱动测试：结构化测试用例管理

表驱动测试（Table-Driven Tests）是Go社区广泛采用的最佳实践，尤其适合Mock隔离场景中多输入、多Mock行为的验证。其核心思想是将测试用例组织为结构体切片，通过循环统一执行。

// 表驱动测试示例：Mock支付服务的多种响应
func TestPaymentService_Charge(t *testing.T) {
    tests := []struct {
        name       string          // 用例名称
        amount     float64
        mockResp   *ChargeResponse // Mock期望响应
        mockErr    error           // Mock期望错误
        wantErr    bool
        wantStatus string
    }{
        {
            name:       "正常扣款",
            amount:     100.0,
            mockResp:   &ChargeResponse{Status: "success", TxID: "tx-001"},
            mockErr:    nil,
            wantErr:    false,
            wantStatus: "success",
        },
        {
            name:       "余额不足",
            amount:     99999.0,
            mockResp:   nil,
            mockErr:    ErrInsufficientBalance,
            wantErr:    true,
            wantStatus: "",
        },
        {
            name:       "金额为零",
            amount:     0.0,
            mockResp:   nil,
            mockErr:    ErrInvalidAmount,
            wantErr:    true,
            wantStatus: "",
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            mockSvc := NewMockPaymentService()
            // 配置Mock期望行为
            mockSvc.On("Charge", tt.amount).Return(tt.mockResp, tt.mockErr)

            got, err := mockSvc.Charge(tt.amount)
            if (err != nil) != tt.wantErr {
                t.Errorf("Charge() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if !tt.wantErr && got.Status != tt.wantStatus {
                t.Errorf("Charge() status = %s, want %s", got.Status, tt.wantStatus)
            }
        })
    }
}

3.3 子测试：嵌套组织与独立控制

子测试（Subtests）通过 t.Run(name, func(t *testing.T)) 实现，允许在单个 Test 函数内创建独立的测试上下文。在Mock隔离调试中，子测试的价值体现在：

• 独立Setup/Teardown： 每个子测试可以拥有独立的Mock初始化与清理逻辑
• 选择性执行： 使用 go test -run TestXxx/用例名 只运行特定子测试
• 并行控制： 子测试内部可调用 t.Parallel() 实现细粒度并行
• 嵌套层级： 子测试可以无限嵌套，适合分层Mock场景

// 子测试嵌套示例：多层Mock调用链
func TestOrderService_PlaceOrder(t *testing.T) {
    // 外层：订单服务整体测试
    t.Run("正常下单流程", func(t *testing.T) {
        mockUserSvc := NewMockUserService()
        mockPaySvc := NewMockPaymentService()
        mockInvSvc := NewMockInventoryService()

        // 内层：库存检查子测试
        t.Run("库存充足", func(t *testing.T) {
            mockInvSvc.On("CheckStock", "sku-001").Return(100, nil)
            // ... 测试逻辑
        })

        // 内层：支付子测试
        t.Run("支付成功", func(t *testing.T) {
            mockPaySvc.On("Charge", 99.9).Return(&ChargeResponse{Status: "success"}, nil)
            // ... 测试逻辑
        })
    })

    t.Run("异常流程-库存不足", func(t *testing.T) {
        mockInvSvc := NewMockInventoryService()
        mockInvSvc.On("CheckStock", "sku-001").Return(0, ErrOutOfStock)
        // ... 测试逻辑
    })
}

3.4 并行测试：加速Mock验证

Go 1.7+ 引入的 t.Parallel() 允许测试用例并发执行。在Mock隔离测试中，合理使用并行测试可以大幅缩短回归验证时间，但需注意Mock对象的线程安全性。

// 并行测试示例：并发验证Mock服务的幂等性
func TestIdempotentMock_Concurrent(t *testing.T) {
    // 为每个子测试创建独立的Mock实例
    tests := []struct {
        name string
        key  string
    }{
        {"并发请求-1", "key-001"},
        {"并发请求-2", "key-002"},
        {"并发请求-3", "key-003"},
        {"并发请求-4", "key-004"},
    }

    for _, tt := range tests {
        tt := tt // 捕获循环变量
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel() // 标记为并行

            // 每个子测试拥有独立的Mock实例，避免共享状态
            mockSvc := NewMockIdempotentService()
            mockSvc.On("Process", tt.key).Return("processed", nil)

            result, err := mockSvc.Process(tt.key)
            if err != nil {
                t.Errorf("Process(%s) error = %v", tt.key, err)
            }
            if result != "processed" {
                t.Errorf("Process(%s) = %s, want 'processed'", tt.key, result)
            }
        })
    }
}

3.5 测试辅助函数与Cleanup机制

Go 1.14+ 的 t.Cleanup 提供了注册清理函数的机制，在Mock隔离测试中用于释放资源、重置Mock状态或关闭网络连接。

// Cleanup 示例：自动清理Mock服务器
func TestWithMockServer(t *testing.T) {
    mockServer := startMockGRPCServer(t)
    // 注册清理函数，即使测试失败也会执行
    t.Cleanup(func() {
        mockServer.Stop()
        t.Log("Mock gRPC server stopped")
    })

    // 测试逻辑...
    client := NewClient(mockServer.Addr())
    resp, err := client.Call(context.Background(), &Request{ID: "test"})
    if err != nil {
        t.Fatalf("Call failed: %v", err)
    }
    // Cleanup 会在函数返回前自动调用
}

3.6 测试覆盖率与Mock边界

Go的 go test -cover 可以度量测试覆盖率。在Mock隔离场景中，覆盖率数据需要结合Mock行为来解读：

3.7 本章知识结构图

3.8 测试执行流程与Mock生命周期

理解测试执行流程有助于定位Mock隔离问题。下图展示了单个测试函数的完整生命周期：

3.9 常见陷阱与调试建议