3. 集成测试基础：Go testing包、TestMain、子测试、表驱动测试、测试辅助函数

集成测试是压测闭环的验证基石。在 Go 项目中，testing 标准库提供了从单测到集成测试的完整能力。本章聚焦于四个核心机制：TestMain（全局生命周期管理）、子测试（分层执行）、表驱动测试（数据与逻辑分离）以及测试辅助函数（减少重复代码）。掌握这些基础，才能构建出可维护、可复用的接口压测用例。

3.1 testing 包的核心约定

Go 的测试文件以 _test.go 结尾，测试函数签名固定为 func TestXxx(t *testing.T)。集成测试与单元测试共享同一框架，区别在于集成测试会真实调用外部依赖（数据库、HTTP 服务、消息队列等）。

概念 函数签名 用途
普通测试 func TestXxx(t *testing.T) 执行单个测试逻辑
TestMain func TestMain(m *testing.M) 全局 setup / teardown
子测试 t.Run(name, func(t *testing.T)) 嵌套执行分组测试
表驱动测试 结构体切片 + 循环 数据驱动，减少重复
辅助函数 func helper(t *testing.T, args...) 封装公共断言/准备逻辑
提示：集成测试文件建议放在 internal/test 或 tests 目录下，与单元测试隔离。使用 //go:build integration 构建标签区分运行环境。

3.2 TestMain：全局生命周期管理

TestMain 是集成测试的入口点。它在同一个包内所有测试函数执行之前运行一次，适合做全局资源初始化（启动测试容器、建立数据库连接、加载配置）和清理工作。

// setup_test.go
package tests

import (
    "os"
    "testing"
)

func TestMain(m *testing.M) {
    // 全局 Setup：启动测试环境
    setupTestEnvironment()

    // 运行所有测试
    code := m.Run()

    // 全局 Teardown：清理资源
    teardownTestEnvironment()

    os.Exit(code)
}

func setupTestEnvironment() {
    // 初始化数据库连接池
    // 启动 mock HTTP 服务
    // 加载测试配置
}

func teardownTestEnvironment() {
    // 关闭连接
    // 清理临时数据
}
注意：TestMain 只能定义一次。如果多个文件都定义了 TestMain，编译会报错。建议将全局生命周期逻辑集中在一个 setup_test.go 文件中。

3.3 子测试：分层执行与并行控制

子测试通过 t.Run 创建嵌套测试层级，支持选择性执行、并行控制和独立错误报告。在接口压测中，子测试常用于按接口分组，每组内再按场景细分。

func TestUserAPI(t *testing.T) {
    // 外层：用户接口组
    t.Run("CreateUser", func(t *testing.T) {
        // 内层：创建用户场景
        t.Run("ValidInput", func(t *testing.T) {
            // 正常创建逻辑
        })
        t.Run("DuplicateEmail", func(t *testing.T) {
            // 重复邮箱错误处理
        })
    })

    t.Run("GetUser", func(t *testing.T) {
        t.Run("ExistingUser", func(t *testing.T) {
            // 查询已有用户
        })
        t.Run("NotFound", func(t *testing.T) {
            // 用户不存在
        })
    })
}

子测试支持 t.Parallel() 标记，实现组内并行执行。压测场景中，常用子测试并行模拟并发请求：

func TestConcurrentRequests(t *testing.T) {
    tests := []string{"endpoint_a", "endpoint_b", "endpoint_c"}
    for _, ep := range tests {
        t.Run(ep, func(t *testing.T) {
            t.Parallel() // 并行执行
            // 发送 HTTP 请求并验证
        })
    }
}

3.4 表驱动测试：数据与逻辑分离

表驱动测试是 Go 社区推荐的标准模式。将测试用例定义为结构体切片，循环执行，每个用例独立命名。这种方式在接口压测中特别适合覆盖多种请求参数组合。

func TestCreateUserAPI(t *testing.T) {
    type testCase struct {
        name       string
        payload    map[string]interface{}
        wantStatus int
        wantErr    bool
    }

    cases := []testCase{
        {
            name:       "valid_user",
            payload:    map[string]interface{}{"name": "Alice", "email": "alice@example.com"},
            wantStatus: 201,
            wantErr:    false,
        },
        {
            name:       "missing_name",
            payload:    map[string]interface{}{"email": "bob@example.com"},
            wantStatus: 400,
            wantErr:    true,
        },
        {
            name:       "invalid_email",
            payload:    map[string]interface{}{"name": "Charlie", "email": "not-an-email"},
            wantStatus: 400,
            wantErr:    true,
        },
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            // 调用被测试接口
            status, err := callCreateUserAPI(tc.payload)
            if status != tc.wantStatus {
                t.Errorf("got status %d, want %d", status, tc.wantStatus)
            }
            if (err != nil) != tc.wantErr {
                t.Errorf("got error %v, wantErr %v", err, tc.wantErr)
            }
        })
    }
}
最佳实践：表驱动测试的用例结构体应包含 name 字段用于子测试命名，便于定位失败用例。压测场景中可额外添加 concurrency、duration 等字段控制压测参数。

3.5 测试辅助函数：消除重复代码

集成测试中，重复的 HTTP 调用、JSON 解析、断言逻辑会大幅增加维护成本。测试辅助函数将公共逻辑提取为可复用的函数，通常以 helper 或 must 前缀命名。

// helper_test.go
package tests

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

// mustNewRequest 创建 HTTP 请求，失败则立即停止测试
func mustNewRequest(t *testing.T, method, url string, body interface{}) *http.Request {
    t.Helper() // 标记为辅助函数，错误行号指向调用方
    var buf bytes.Buffer
    if err := json.NewEncoder(&buf).Encode(body); err != nil {
        t.Fatalf("failed to encode request body: %v", err)
    }
    req, err := http.NewRequest(method, url, &buf)
    if err != nil {
        t.Fatalf("failed to create request: %v", err)
    }
    return req
}

// assertStatus 断言 HTTP 响应状态码
func assertStatus(t *testing.T, got, want int) {
    t.Helper()
    if got != want {
        t.Errorf("status code: got %d, want %d", got, want)
    }
}

// parseResponse 解析 JSON 响应到目标结构体
func parseResponse(t *testing.T, resp *http.Response, target interface{}) {
    t.Helper()
    defer resp.Body.Close()
    if err := json.NewDecoder(resp.Body).Decode(target); err != nil {
        t.Fatalf("failed to decode response: %v", err)
    }
}

在测试函数中使用辅助函数，代码量减少 40% 以上：

func TestCreateUserWithHelper(t *testing.T) {
    server := httptest.NewServer(handler())
    defer server.Close()

    payload := map[string]string{"name": "Alice", "email": "alice@example.com"}
    req := mustNewRequest(t, http.MethodPost, server.URL+"/users", payload)

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        t.Fatalf("request failed: %v", err)
    }

    assertStatus(t, resp.StatusCode, 201)

    var user User
    parseResponse(t, resp, &user)
    if user.Name != "Alice" {
        t.Errorf("user name: got %s, want Alice", user.Name)
    }
}

3.6 集成测试执行流程

下图展示了集成测试从启动到结束的完整生命周期，包含 TestMain 全局控制、子测试分层执行以及辅助函数的调用关系：

集成测试执行流程 TestMain(m *testing.M) setupTestEnvironment() m.Run() 执行所有测试 子测试组 A t.Run("CreateUser") t.Run("GetUser") t.Run("DeleteUser") 子测试组 B t.Run("ValidInput") t.Run("DuplicateEmail") t.Run("InvalidPayload") 子测试组 C t.Run("Concurrent10") t.Run("Concurrent50") t.Run("Concurrent100") 测试辅助函数：mustNewRequest() / assertStatus() / parseResponse() teardownTestEnvironment()

3.7 常见陷阱与避坑指南

  • TestMain 重复定义：同一个包内只能有一个 TestMain，否则编译失败。将全局逻辑集中到 setup_test.go。
  • t.Helper() 缺失：辅助函数不调用 t.Helper() 时，错误行号指向辅助函数内部而非调用处，增加排查难度。
  • 子测试未命名：表驱动测试中忘记给每个用例设置 name 字段，导致失败时无法区分具体用例。
  • 并行测试共享状态：子测试使用 t.Parallel() 时，如果共享外部变量（如数据库连接），需确保线程安全或使用 t.Run 隔离。
  • 集成测试与单元测试混跑：未使用构建标签或目录隔离，导致单元测试环境也执行了依赖外部服务的集成测试。
压测集成要点：在压测闭环中，集成测试用例可直接复用为压测脚本的验证逻辑。将表驱动测试的用例结构体扩展为包含 concurrency、rampUp 等压测参数，实现测试与压测的统一数据源。
← 上一章 📖 返回目录 下一章 →