Go语言 测试框架Table Driven Tests最佳实践

Table Driven Tests（表驱动测试）是 Go 语言标准库中广泛采用的一种测试模式。它通过在切片中定义测试用例结构体，并在循环中执行测试逻辑，避免了重复代码，提高了测试的可维护性和可读性。

1. 构建基础表驱动测试结构

传统的测试写法往往存在大量重复的 if 判断和测试逻辑。表驱动测试的核心在于将“输入”和“预期输出”数据与“测试逻辑”分离。

定义测试用例结构体，通常包含用例名称、输入参数和期望结果。

创建一个切片，包含所有需要覆盖的场景（正常情况、边界情况、错误情况）。

编写测试逻辑，遍历切片并执行断言。

以下是一个字符串分割函数的测试示例：

func TestSplit(t *testing.T) {
    // 1. 定义测试用例结构体
    tests := []struct {
        name  string
        input string
        sep   string
        want  []string
    }{
        // 2. 填充测试数据
        {name: "simple", input: "a/b/c", sep: "/", want: []string{"a", "b", "c"}},
        {name: "wrong sep", input: "a/b/c", sep: ",", want: []string{"a/b/c"}},
        {name: "trailing sep", input: "a/b/c/", sep: "/", want: []string{"a", "b", "c", ""}},
        {name: "empty string", input: "", sep: "/", want: []string{""}},
    }

    // 3. 遍历执行测试
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Split(tt.input, tt.sep)
            if !reflect.DeepEqual(got, tt.want) {
                t.Errorf("Split(%q, %q) = %v, want %v", tt.input, tt.sep, got, tt.want)
            }
        })
    }
}

2. 使用子测试隔离执行环境

在循环中直接调用 t.Errorf 会导致一个问题：一旦某个用例失败引发 panic，后续的测试用例可能无法执行。此外，难以单独运行某个特定的失败用例。

调用 t.Run(tt.name, func(t *testing.T) { ... }) 方法，将每个测试用例封装在一个独立的子测试中。

配置子测试的名称，确保每个名称唯一且具有描述性。

执行上述代码后，使用 go test -v 命令可以看到清晰的层级输出。如果某个用例失败，只需运行 go test -run TestSplit/simple 即可单独调试该用例。

3. 处理复杂的测试辅助函数

当测试逻辑涉及复杂的对象创建或资源清理时，不要将其写在循环内部。

提取公共的 setup 和 teardown 逻辑到独立的辅助函数中。

使用 defer 确保资源（如临时文件、数据库连接）被正确释放。

以下示例展示了如何处理包含文件操作的测试：

func setupTestFile(t *testing.T, content string) string {
    t.Helper()
    tmpfile, err := os.CreateTemp("", "example")
    if err != nil {
        t.Fatal(err)
    }
    if _, err := tmpfile.Write([]byte(content)); err != nil {
        t.Fatal(err)
    }
    return tmpfile.Name()
}

func TestProcessFile(t *testing.T) {
    tests := []struct {
        name    string
        content string
        want    string
    }{
        {"valid json", `{"key": "value"}`, "processed"},
        {"invalid json", `{invalid}`, "error"},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // 使用辅助函数创建资源
            path := setupTestFile(t, tt.content)
            defer os.Remove(path) // 清理资源

            got := ProcessFile(path)
            if got != tt.want {
                t.Errorf("got %q, want %q", got, tt.want)
            }
        })
    }
}

注意：在辅助函数中调用 t.Helper()，这样报错时的行号会指向调用处（即测试用例代码），而不是辅助函数内部。

4. 实现并行测试加速执行

Go 的测试天然支持并发。对于相互独立的用例，可以通过并行运行显著减少测试时间。

在 t.Run 的闭包函数开头调用 t.Parallel()。

确保测试用例之间没有共享状态或竞态条件。

修改后的代码如下：

func TestParallelSplit(t *testing.T) {
    tests := []struct {
        name  string
        input string
        sep   string
        want  []string
    }{
        // ... 填充用例 ...
    }

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

            got := Split(tt.input, tt.sep)
            if !reflect.DeepEqual(got, tt.want) {
                t.Errorf("Split(%q, %q) = %v, want %v", tt.input, tt.sep, got, tt.want)
            }
        })
    }
}

重点：使用 tt := tt 这一惯用写法。因为在循环中，变量 tt 是按地址传递给闭包的。如果不创建局部变量，并发执行时所有子测试可能共用同一个 tt 值，导致测试结果不可预测。

5. 测试数据与逻辑分离的最佳实践

当代码库变得庞大，或者测试用例非常多时，将测试数据硬编码在 .go 文件中会显得臃肿。对于一些标准化的输入输出（如 JSON/YAML），可以考虑外部化。

创建一个 testdata 目录。

放置测试数据文件（如 input.json, golden.txt）。

在测试代码中使用 os.ReadFile 读取数据。

这种方法常用于“Golden File Testing”（黄金文件测试），即先将程序的输出写入一个文件作为标准，后续测试时将实际输出与该文件对比。

func TestGoldenOutput(t *testing.T) {
    tests := []struct {
        name     string
        filename string
    }{
        {"case1", "testdata/case1.golden"},
        {"case2", "testdata/case2.golden"},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()

            // 读取期望结果
            want, _ := os.ReadFile(tt.filename)

            // 获取实际结果
            got := GenerateOutput()

            // 对比
            if string(got) != string(want) {
                t.Errorf("Result does not match golden file %s", tt.filename)
            }
        })
    }
}

维护黄金文件时，如果确认逻辑变更导致输出变化是合理的，运行 go test -update-golden（需自定义 flag 或手动更新）来覆盖旧文件。