Go-07-单元测试与 TDD

字数统计: 1.6k字   |   阅读时长≈ 8分

Go-07-单元测试与 TDD

本节目标：掌握 Go 内置 testing 包的基本用法、表驱动测试、基准测试，理解 TDD 流程。

1. 第一个测试

Go 的测试约定：

  • 测试文件以 _test.go 结尾
  • 测试函数签名：func TestXxx(t *testing.T)
  • 在 *_test.go 里可以访问包内未导出标识符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// math.go
package math

func Add(a, b int) int { return a + b }

// math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
    got := Add(1, 2)
    if got != 3 {
        t.Errorf("Add(1, 2) = %d, want 3", got)
    }
}

运行测试：

1
2
3
4
5
6
7
8
go test                        # 当前包
go test ./...                  # 所有子包
go test -v                     # 详细输出
go test -run TestAdd           # 只跑指定测试
go test -count=1               # 关闭缓存
go test -cover                 # 显示覆盖率
go test -coverprofile=cover.out # 覆盖率 profile
go tool cover -html=cover.out  # 浏览器看覆盖率

2. Table-Driven Tests（表驱动测试）

Go 社区强烈推崇的测试风格：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive", 1, 2, 3},
        {"negative", -1, -2, -3},
        {"zero", 0, 0, 0},
        {"mixed", 5, -3, 2},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.expected {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}

输出：

1
2
3
4
5
6
7
8
9
10
11
=== RUN   TestAdd
=== RUN   TestAdd/positive
=== RUN   TestAdd/negative
=== RUN   TestAdd/zero
=== RUN   TestAdd/mixed
--- PASS: TestAdd (0.00s)
    --- PASS: TestAdd/positive (0.00s)
    --- PASS: TestAdd/negative (0.00s)
    --- PASS: TestAdd/zero (0.00s)
    --- PASS: TestAdd/mixed (0.00s)
PASS

3. 常用测试工具

3.1 t.Helper() 和 t.Errorf / t.Fatalf

1
2
3
4
5
6
7
8
9
10
func assertEqual(t *testing.T, got, want interface{}) {
    t.Helper()  // 标记为辅助函数，错误时报告调用方的位置
    if got != want {
        t.Errorf("got %v, want %v", got, want)
    }
}

func TestAdd(t *testing.T) {
    assertEqual(t, Add(1, 2), 3)
}

t.Fatalf vs t.Errorf：

  • Errorf 记录错误继续执行
  • Fatalf 记录错误立即停止当前测试

3.2 t.Skip() 跳过条件测试

1
2
3
4
5
6
func TestLinuxOnly(t *testing.T) {
    if runtime.GOOS != "linux" {
        t.Skip("requires Linux")
    }
    // Linux 特定的测试
}

3.3 子测试与子 subtests

1
2
3
4
5
6
7
8
func TestMath(t *testing.T) {
    t.Run("Add", func(t *testing.T) {
        // ...
    })
    t.Run("Sub", func(t *testing.T) {
        // ...
    })
}

运行：go test -run TestMath/Add

4. 测试 HTTP 处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Query().Get("name"))
}

func TestHelloHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/hello?name=Alice", nil)
    w := httptest.NewRecorder()

    helloHandler(w, req)

    if w.Code != http.StatusOK {
        t.Errorf("status = %d, want 200", w.Code)
    }
    if got := w.Body.String(); got != "Hello, Alice!" {
        t.Errorf("body = %q, want %q", got, "Hello, Alice!")
    }
}

测试完整 HTTP 服务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func TestServer(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(helloHandler))
    defer srv.Close()

    resp, err := http.Get(srv.URL + "/hello?name=Bob")
    if err != nil {
        t.Fatal(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    if string(body) != "Hello, Bob!" {
        t.Errorf("got %q, want %q", body, "Hello, Bob!")
    }
}

5. 基准测试（Benchmark）

1
2
3
4
5
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(i, i+1)
    }
}

运行：

1
2
3
go test -bench=.              # 跑所有 benchmark
go test -bench=BenchmarkAdd   # 跑指定
go test -bench=. -benchmem   # 显示内存分配

输出：

1
BenchmarkAdd-8    1000000000    0.254 ns/op    0 B/op    0 allocs/op

6. 示例测试（Example Test）

1
2
3
4
func ExampleAdd() {
    fmt.Println(Add(1, 2))
    // Output: 3
}

// Output: 注释让 go test 验证输出。如果改了 Add 但忘了更新示例，测试会失败 —— 文档和测试同步。

7. TDD 流程实战

TDD = Test-Driven Development：先写测试，再写实现。

例：实现一个判断回文字符串的函数。

Step 1（Red）：先写测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// palindrome_test.go
package strings

import "testing"

func TestIsPalindrome(t *testing.T) {
    tests := []struct {
        name string
        s    string
        want bool
    }{
        {"empty", "", true},
        {"single", "a", true},
        {"simple", "aba", true},
        {"complex", "A man, a plan, a canal: Panama", true},
        {"race", "racecar", true},
        {"not", "hello", false},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := IsPalindrome(tt.s); got != tt.want {
                t.Errorf("IsPalindrome(%q) = %v, want %v", tt.s, got, tt.want)
            }
        })
    }
}

Step 2：跑测试，看到失败（因为 IsPalindrome 还不存在）

1
2
3
$ go test
# palindrome_test.go:9:2: undefined: IsPalindrome
FAIL

Step 3（Green）：写最简单的实现让测试通过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// palindrome.go
package strings

import "strings"

func IsPalindrome(s string) bool {
    s = strings.ToLower(s)
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        if runes[i] != runes[j] {
            return false
        }
    }
    return true
}

Step 4（Refactor）：重构实现 + 测试

测试全过：

1
2
3
4
5
$ go test -v
=== RUN   TestIsPalindrome
--- PASS: TestIsPalindrome (0.00s)
PASS
ok      strings    0.003s

8. Mock 和依赖注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
type UserStore interface {
    GetUser(id string) (*User, error)
}

type UserService struct {
    store UserStore
}

func (s *UserService) GetUserName(id string) (string, error) {
    u, err := s.store.GetUser(id)
    if err != nil {
        return "", err
    }
    return u.Name, nil
}

// 测试用的 mock
type fakeStore struct {
    users map[string]*User
}
func (f *fakeStore) GetUser(id string) (*User, error) {
    u, ok := f.users[id]
    if !ok {
        return nil, errors.New("not found")
    }
    return u, nil
}

func TestGetUserName(t *testing.T) {
    s := &UserService{
        store: &fakeStore{
            users: map[string]*User{
                "1": {ID: "1", Name: "Alice"},
            },
        },
    }
    name, err := s.GetUserName("1")
    if err != nil {
        t.Fatal(err)
    }
    if name != "Alice" {
        t.Errorf("got %q, want %q", name, "Alice")
    }
}

9. testify 库（推荐）

虽然 stdlib 够用，但 testify 让测试更简洁：

1
2
3
4
5
6
7
8
9
10
11
12
13
import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestAdd(t *testing.T) {
    assert.Equal(t, 3, Add(1, 2))
    assert.NotNil(t, &User{})
    assert.True(t, IsPalindrome("aba"))
    assert.Contains(t, "hello world", "world")
    require.NoError(t, err)  // require = assert + FailNow
}

10. 测试覆盖率

1
2
3
4
5
6
7
go test -cover
# ok  strings  0.003s  coverage: 100.0% of statements

# HTML 报告
go test -coverprofile=cover.out
go tool cover -html=cover.out -o cover.html
# 浏览器打开 cover.html

**Go 1.20+**：可以按包分别看覆盖率

1
2
go test -coverprofile=cover.out ./...
go tool cover -func=cover.out

11. 黄金法则

  • 测试和代码一起提交（同 PR）
  • bug 修复先写测试（重现 bug），再修复
  • 不要测第三方库（只测自己的代码）
  • 覆盖率不是越高越好（100% 不代表无 bug）
  • 测试要快（慢的测试会被跳过）

小结

工具 用法
go test 跑测试
go test -bench 跑基准
go test -cover 覆盖率
t.Run 子测试
t.Helper() 辅助函数标记
t.Skip() 跳过条件
httptest HTTP handler 测试
testify 更便捷的断言库

TDD 节奏：Red → Green → Refactor，每个循环 5-10 分钟。

下一节讲 Go 的代码组织：包、模块、go.mod。

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870