2、Go testing基础：testing包核心结构、Test函数签名、t *testing.T常用方法、子测试与表驱动测试

在Go语言生态中，testing标准库是编写单元测试、基准测试和示例函数的基石。对于Web服务契约压测而言，理解testing包的核心结构、Test函数签名以及t *testing.T的常用方法，是构建可维护、可扩展压测脚本的前提。本节将系统梳理这些基础概念，并重点介绍子测试与表驱动测试在压测场景下的应用。

2.1 testing包核心结构

testing包的核心设计围绕三个主要对象展开：T（测试）、B（基准测试）和M（测试主程序）。在契约压测中，我们主要与T和B打交道。

对象 类型 主要用途 压测场景关联
T *testing.T 单元测试与功能测试的控制句柄 验证单个请求的响应状态码、响应体结构、Header等契约
B *testing.B 基准测试的控制句柄 执行并发请求、统计吞吐量（QPS）、延迟分布（P99）
M *testing.M 测试主程序，控制测试生命周期 在压测前后初始化/清理全局资源（如数据库连接、Mock Server）
提示： 在契约压测中，t *testing.T 用于断言响应是否符合契约规范，而 b *testing.B 用于驱动压力负载。两者在同一个测试文件中可以共存，但函数签名不同。

2.2 Test函数签名

Go语言规定，一个合法的Test函数必须满足以下签名规则：

func TestXxx(t *testing.T) {
    // 测试逻辑
}

关键约束：

  • 函数名必须以 Test 开头，且首字母大写的后续部分通常描述被测试功能。
  • 参数必须且只能是 *testing.T 类型。
  • 函数不能有返回值。
  • 测试文件必须以 _test.go 结尾。

对于基准测试（压测核心），函数签名为：

func BenchmarkXxx(b *testing.B) {
    for i := 0; i < b.N; i++ {
        // 被测量的操作
    }
}

b.N 由框架自动调整，确保测试有足够的运行时间以获得稳定统计。

2.3 t *testing.T 常用方法

在契约压测中，t 对象提供了丰富的断言和日志方法。以下是高频使用的方法清单：

方法 签名 行为说明 压测场景示例
Error Error(args ...any) 记录错误日志，标记测试失败，但继续执行当前测试 响应状态码不符合预期时记录错误，继续检查响应体
Errorf Errorf(format string, args ...any) 格式化版Error t.Errorf("期望状态码 %d，实际 %d", 200, resp.StatusCode)
Fatal Fatal(args ...any) 记录错误日志，标记测试失败，立即停止当前测试 连接服务器失败时直接终止，避免后续空指针
Fatalf Fatalf(format string, args ...any) 格式化版Fatal t.Fatalf("无法创建HTTP请求: %v", err)
Log Log(args ...any) 记录测试日志，仅在测试失败或指定 -v 时输出 打印请求URL、耗时等调试信息
Logf Logf(format string, args ...any) 格式化版Log t.Logf("请求耗时: %v", elapsed)
Skip Skip(args ...any) 跳过当前测试，标记为已跳过 当依赖的外部服务不可用时跳过压测
Parallel Parallel() 标记测试为可并行执行 在子测试中调用，实现并发压测场景
Run Run(name string, f func(t *testing.T)) bool 运行子测试 组织多个契约用例，实现表驱动测试
注意： 在压测场景中，Fatal/Fatalf 会立即终止当前测试函数，可能导致后续清理代码无法执行。建议在资源清理无关紧要的断言中使用，否则优先使用 Error/Errorf 配合 defer 清理。

2.4 子测试与表驱动测试

子测试（Subtest）是Go 1.7引入的特性，允许在单个Test函数内运行多个独立的测试用例。表驱动测试（Table-Driven Test）则是利用子测试和匿名结构体切片，将测试输入与期望输出组织成表格形式，极大提升测试代码的可读性和可维护性。

在契约压测中，表驱动测试非常适合组织不同接口、不同参数组合的契约验证。

2.4.1 子测试基础用法

func TestUserAPI(t *testing.T) {
    t.Run("获取用户信息-正常用户", func(t *testing.T) {
        // 测试逻辑
        resp, err := http.Get("http://api.example.com/user/1")
        if err != nil {
            t.Fatalf("请求失败: %v", err)
        }
        if resp.StatusCode != http.StatusOK {
            t.Errorf("期望 200，实际 %d", resp.StatusCode)
        }
    })

    t.Run("获取用户信息-不存在的用户", func(t *testing.T) {
        resp, err := http.Get("http://api.example.com/user/99999")
        if err != nil {
            t.Fatalf("请求失败: %v", err)
        }
        if resp.StatusCode != http.StatusNotFound {
            t.Errorf("期望 404，实际 %d", resp.StatusCode)
        }
    })
}

2.4.2 表驱动测试模式

表驱动测试的核心模式：定义一个测试用例切片，每个元素包含名称、输入、期望输出，然后循环调用 t.Run。

func TestUserContract(t *testing.T) {
    tests := []struct {
        name       string
        userID     string
        wantStatus int
        wantBody   string
    }{
        {
            name:       "正常用户-管理员",
            userID:     "1",
            wantStatus: 200,
            wantBody:   `"role":"admin"`,
        },
        {
            name:       "正常用户-普通用户",
            userID:     "2",
            wantStatus: 200,
            wantBody:   `"role":"user"`,
        },
        {
            name:       "不存在的用户",
            userID:     "99999",
            wantStatus: 404,
            wantBody:   `"error":"user not found"`,
        },
        {
            name:       "非法用户ID-负数",
            userID:     "-1",
            wantStatus: 400,
            wantBody:   `"error":"invalid user id"`,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            url := fmt.Sprintf("http://api.example.com/user/%s", tt.userID)
            resp, err := http.Get(url)
            if err != nil {
                t.Fatalf("请求失败: %v", err)
            }
            defer resp.Body.Close()

            if resp.StatusCode != tt.wantStatus {
                t.Errorf("状态码: 期望 %d, 实际 %d", tt.wantStatus, resp.StatusCode)
            }

            bodyBytes, _ := io.ReadAll(resp.Body)
            bodyStr := string(bodyBytes)
            if !strings.Contains(bodyStr, tt.wantBody) {
                t.Errorf("响应体: 期望包含 %q, 实际 %q", tt.wantBody, bodyStr)
            }
        })
    }
}
最佳实践： 在契约压测中，表驱动测试的每个用例应覆盖一个独立的契约场景。建议将测试用例定义在独立的变量或函数中，便于后续扩展和复用。同时，结合 t.Parallel() 可以在子测试中实现并发压测。

2.5 子测试与表驱动测试的SVG结构图

下图展示了子测试与表驱动测试在Go testing中的执行流程与组织关系：

子测试与表驱动测试执行结构 TestUserContract for _, tt := range tests { t.Run(tt.name, ...) } 子测试: 正常用户 userID: "1" 子测试: 普通用户 userID: "2" 子测试: 不存在用户 userID: "99999" 子测试: 非法ID userID: "-1" 发送HTTP请求 断言状态码 断言响应体 每个子测试独立报告结果

2.6 子测试并行执行与压测结合

在契约压测中，子测试配合 t.Parallel() 可以实现并发请求，模拟真实用户负载。以下是一个结合表驱动测试与并行的示例：

func TestParallelContract(t *testing.T) {
    endpoints := []struct {
        name string
        path string
    }{
        {"首页", "/"},
        {"用户列表", "/api/users"},
        {"商品列表", "/api/products"},
        {"订单查询", "/api/orders"},
    }

    for _, ep := range endpoints {
        ep := ep // 捕获循环变量
        t.Run(ep.name, func(t *testing.T) {
            t.Parallel() // 标记为并行执行
            resp, err := http.Get("http://api.example.com" + ep.path)
            if err != nil {
                t.Fatalf("请求 %s 失败: %v", ep.path, err)
            }
            defer resp.Body.Close()

            if resp.StatusCode != http.StatusOK {
                t.Errorf("路径 %s: 期望 200，实际 %d", ep.path, resp.StatusCode)
            }
        })
    }
}
注意： 使用 t.Parallel() 时，必须捕获循环变量（ep := ep），否则所有子测试可能共享最后一个迭代的值。这是Go闭包常见的陷阱。

2.7 常用方法速查表

为方便日常开发，下表汇总了 t *testing.T 在契约压测中最常用的方法及其适用场景：

方法 调用时机 对测试流程的影响 推荐使用场景
Error/Errorf 断言失败时 标记失败，继续执行 响应体字段校验、Header校验等非致命断言
Fatal/Fatalf 前置条件不满足时 标记失败，立即停止 网络连接失败、Token获取失败等致命错误
Log/Logf 调试或信息记录 不影响测试结果 打印请求耗时、响应大小等辅助信息
Skip/Skipf 条件不满足时 跳过测试，不计入失败 依赖环境变量、外部服务不可用时优雅跳过
Parallel 子测试函数开头 使测试进入并行等待组 并发压测场景，模拟多用户同时请求
Run 组织子测试 创建子测试作用域 表驱动测试、分组测试、嵌套测试

掌握这些基础结构和方法，是后续编写高效、可维护的契约压测脚本的起点。在下一节中，我们将深入探讨如何利用 testing.B 构建基准测试，并配置压测参数。

← 上一章 📖 返回目录 下一章 →