扫码关注公众号，手机阅读更方便

前言

在软件开发中，单元测试是一项不可忽视的环节。它不仅帮助开发者在编码的早期阶段发现并解决潜在问题，还能确保代码的可靠性、可维护性和整体质量，这对于提高开发效率、减少后期维护成本非常重要。

尤其是当你在后期对某个函数或方法进行优化时，之前编写的测试用例就显得非常重要。如果测试通过，你会感到欣慰，说明优化后的代码没有破坏现有功能；如果测试失败，那也是好事，因为你及时发现了潜在问题，避免了线上故障的风险。

在 Go 语言中，go test 命令和 testing 包提供了简洁而强大的测试机制，使得 Gopher 能轻松编写并执行测试用例。本文将详细介绍如何使用 Go 语言中的 testing 包编写高效的单元测试，探讨 go test 命令的常用参数及其作用，并通过子测试和表格驱动测试的实践方法提升代码质量。文章还会介绍 TestMain 函数的使用场景，外部测试工具库如 testify 的应用，以及常用的断言方法。

准备好了吗？准备一杯你最喜欢的咖啡或茶，随着本文一探究竟吧。

基本的测试结构

• Go 语言的测试文件通常放置在与被测试的源文件相同的包中，文件名以 _test.go 结尾。比如，reverse.go 文件的测试文件应命名为 reverse_test.go。这样 go test 命令将能够正确识别和执行测试。
• 每个测试函数的命名必须以 Test 开头，后接大写字母开头的函数名。测试函数的签名为 func (t *testing.T)，其中 t *testing.T 是用于管理测试状态和报告测试失败的参数。

├── stringx/
│   ├── reverse.go
│   └── reverse_test.go

简单案例

在 reverse.go 里：

package stringx

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

在 reverse_test.go 里：

package stringx

import (
    "testing"
)

func TestReverse(t *testing.T) {
    got := Reverse("陈明勇")
    if got != "勇明陈" {
        t.Errorf("expected 勇明陈, but got %s", got)
    }
}

当 Reverse 返回的结果是非预期结果时，使用 t.Errorf 方法报告测试失败，并打印相关的参数信息。

在 stringx 目录下执行 go test 命令：

$ go test
PASS
ok      test_example/stringx    0.166s

go test 常用的参数及其说明

• -v
  • 作用：显示详细的测试输出，包括每个测试用例的执行情况（测试函数的名字和通过/失败的状态）。
  • 示例：go test -v

    $ go test -v       
    === RUN   TestReverse
    --- PASS: TestReverse (0.00s)
    PASS
    ok      test_example/stringx    0.284s
  

• -cover
  • 作用：运行测试并显示代码覆盖率的简要统计信息。
  • 示例：go test -cover

    $ go test -cover
    PASS
    coverage: 100.0% of statements
    ok      test_example/stringx    0.174s
    

• -run <regex>
  • 作用：只运行匹配指定正则表达式的测试函数。
  • 示例：go test -run ^TestFunction$ 只运行 TestFunction。
• -bench <regex>
  • 作用：只运行匹配正则表达式的基准测试（函数名通常以 Benchmark 开头）。
  • 示例：go test -bench . 运行所有基准测试。
• -benchmem
  • 作用：在运行基准测试时，报告内存分配统计信息。
  • 示例：go test -bench . -benchmem
• -coverprofile=<filename>
  • 作用：生成代码覆盖率的详细报告并保存到指定的文件中。
  • 示例：go test -coverprofile=coverage.out
• -covermode=<mode>
  • 作用：指定覆盖模式，有三种模式：
    • set: 统计哪些语句被执行（默认）。
    • count: 统计每个语句被执行的次数。
    • atomic: 统计语句执行次数，并确保多线程安全。
  • 示例：go test -covermode=count
• -timeout=<duration>
  • 作用：设置测试运行的超时时间，防止测试长时间挂起，默认超时时间为 10 分钟。
  • 示例：go test -timeout=30s
• -short
  • 作用：告诉测试程序跳过较长的测试。常用于缩短测试时间。
  • 示例：go test -short
• -parallel=<n>
  • 作用：设置并行执行测试的最大 Goroutine 数量。
  • 示例：go test -parallel=4
• -race
  • 作用：开启数据竞争检测，适用于并发程序的测试。
  • 示例：go test -race
• -count=<n>
  • 作用：指定测试的重复运行次数，通常用于检测偶发性错误。
  • 示例：go test -count=3
• -json
  • 作用：输出测试结果为 JSON 格式，适用于与 CI 系统集成或日志分析。
  • 示例：go test -json
• -failfast
  • 作用：在测试失败时立即停止执行剩余的测试。
  • 示例：go test -failfast

常用组合命令：

• 代码覆盖率分析并生成 HTML 报告：

    go test -coverprofile=coverage.out && go tool cover -html=coverage.out
  

• 运行所有测试并输出详细信息：

  go test -v ./...
  

这些参数可以根据测试需求灵活组合使用，有助于提高测试的覆盖率、性能分析以及调试能力。

更多的参数可通过运行 go help test 命令进行查看。

子测试的表格驱动测试

表格驱动测试（Table-driven tests）是 Go 语言中常见的测试模式，它通过将多个测试用例组织在一个表格（通常是一个切片）中，使用循环依次执行每个测试用例，从而提高代码的可读性和可维护性。

package stringx

import (
    "testing"
)

func TestReverse(t *testing.T) {
    testCases := []struct {
        name     string
        input    string
        expected string
    }{
        {"empty string", "", ""},                     // 测试空字符串
        {"reverse Chinese characters", "陈明勇", "勇明陈"}, // 测试中文字符
        {"reverse English word", "Hello", "olleH"},   // 测试英文单词
    }
    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            got := Reverse(tc.input)
            if got != tc.expected {
                t.Errorf("expected %s, but got %s", tc.expected, got)
            }
        })
    }
}

代码解释：

• 表格：testCases 是一个切片，包含多个结构体，每个结构体代表一个测试用例。
• 循环测试：通过 for _, tc := range testCases 循环每个测试用例。
• 子测试：通过 t.Run(tc.name, ...) 方法为每个测试用例创建子测试，这样在运行测试时，可以在控制台输出的信息中看到每个子测试的名称和结果，方便调试和排查问题。

基于表格驱动测试的好处

• 减少代码的重复性： 避免为每个测试用例单独编写一个测试函数。所有测试用例的核心测试逻辑都可以复用，从而减少代码的冗余。
• 提高测试代码的可维护性： 如果需要添加新的测试用例，只需在表格（切片）中添加新的数据行，而不需要修改核心测试逻辑。
• 提高代码的可读性： 测试用例和核心测试逻辑的分离，使测试代码更加简洁、易于理解。

TestMain 函数

TestMain 在测试模块里是一个特殊的函数，用于在执行测试之前或之后执行全局的初始化和清理工作，它是整个测试包的入口点。在运行 go test 命令之后，首先会检查包测试文件里是否定义了 TestMain 函数，如果有，则会调用它来执行测试。如果没有 TestMain 函数，则会默认调用所有的 TextXxx 函数。

TestMain 的函数签名如下所示：

TestMain(m *testing.M)

TestMain 函数通常结合 setup 和 teardown 函数一起使用，前者用于在测试执行之前做一些准备工作（例如连接数据库，初始化配置等），后者用于在测试执行之后做一些清理工作（例如关闭数据库的链接，删除临时文件等）。

下面是代码示例：

package stringx

import (
    "fmt"
    "os"
    "testing"
)

func TestReverse(t *testing.T) {
    testCases := []struct {
        name     string
        input    string
        expected string
    }{
        {"empty string", "", ""},                     // 测试空字符串
        {"reverse Chinese characters", "陈明勇", "勇明陈"}, // 测试中文字符
        {"reverse English word", "Hello", "olleH"},   // 测试英文单词
    }
    for _, tc := range testCases {
        t.Run(tc.name, func(t *testing.T) {
            got := Reverse(tc.input)
            if got != tc.expected {
                t.Errorf("expected %s, but got %s", tc.expected, got)
            }
        })
    }
}

func setup() {
    fmt.Println("Before running tests")
}

func teardown() {
    fmt.Println("After running tests")
}

func TestMain(m *testing.M) {
    setup()
    code := m.Run()
    teardown()
    os.Exit(code)
}

关键代码解释：

• m.Run()：通过该方法执行所有的测试函数。它返回一个整数，表示测试的状态码，通常为 0 表示成功，非 0 表示有失败的测试。
• os.Exit(code) ：返回测试结果，确保正确的退出状态。

外部测试工具库

在前面的代码示例中，我们使用 != 运算符来比较 结果 和 预期值 是否不相等，这对于基本数据类型是可行的。然而，当我们需要比较像切片、map 等复杂数据结构时，直接使用 != 就不再适用，必须编写额外的逻辑来进行比较。为了解决这个问题，我们可以借助第三方库，例如 testify，来简化这些比较操作。

testify 工具库

testify 是在 Go 语言中被广泛使用的第三方测试库，它提供了一些便捷的断言方法、测试套件支持和 mock 功能，极大地简化了测试代码的编写。相比 Go 自带的 testing 库，testify 提供了更丰富的函数来进行断言判断，特别是在处理复杂数据结构时更加方便。

我们可以通过以下命令安装 testify 模块：

go get github.com/stretchr/testify

接下来我们就可以将前面展示的部分代码：

if got != tc.expected {
    t.Errorf("expected %s, but got %s", tc.expected, got)
}

改写成：

assert.Equalf(t, tc.expected, got, "expected %s, but got %s", tc.expected, got)

当断言失败时，会打印出后面的信息。

testify 常用的断言方法

testify/assert 提供了丰富的断言函数，便于我们进行复杂的比较操作。以下是一些常用的断言函数：

• assert.Equal
  断言两个值相等，适用于基本类型、结构体等。

  assert.Equal(t, "勇明陈", Reverse("陈明勇"))  // Reverse("陈明勇" 是否等于 "勇明陈"
  

• assert.NotNil
  断言对象不为 nil。

  var obj = &struct{}{}
  assert.NotNil(t, obj)
  

• assert.True
  断言条件为 true。

  var b bool
  assert.True(t, b)
  

• assert.False
  断言条件为 false。

  var b bool
  assert.False(t, b)
  

• assert.ElementsMatch
  用于比较两个切片是否包含相同的元素，无论元素的顺序如何。

  expected := []int{1, 2, 3, 4}
  actual := []int{4, 3, 2, 1}
  assert.ElementsMatch(t, expected, actual)  
  

• assert.Len
  断言集合（如切片、map 等）的长度是否等于指定值。

  assert.Len(t, []int{1, 2, 3}, 3)
  

更多的函数信息，请参考 testify/assert。

除了 assert 包，testify 库还提供了另一个 require 包，它与 assert 包的功能类似，都是用于断言的。二者的主要区别在于测试失败时的处理方式：

• 当断言失败时，assert 包会记录失败信息，但测试会继续执行后续的代码。

  assert.Equal(t, "陈明勇", Reverse("陈明勇")) // 失败时记录失败，但继续执行后面的代码
  assert.Equal(t, "勇明陈", Reverse("陈明勇")) // 这个断言仍会执行
  

• 当断言失败时，require 包会立即停止当前测试的执行，并输出错误信息。测试不会继续执行后续的代码。

  require.Equal(t, "陈明勇", Reverse("陈明勇")) // 失败时立即停止执行后续代码
  require.Equal(t, "勇明陈", Reverse("陈明勇")) // 如果前一个断言失败，这个不会被执行
  

我们可以根据具体测试场景选择合适的包，比如在一些关键步骤需要确保不通过就终止测试时使用 require，而对于不那么关键的步骤可以使用 assert，以便测试能继续执行并获得更多结果。

小结

通过本文的介绍，相信你已经掌握了如何在 Go 语言中编写高效的单元测试。从基本的测试结构到表格驱动测试，再到使用外部库 testify 进行更加灵活的断言操作，以及对 go test 命令及其常用参数的掌握。

单元测试不仅是提高代码质量的关键环节，也是保障项目长期稳定的重要实践。无论是个人项目还是大型团队开发，都应该重视测试在整个开发流程中的重要性。