Go / 系统课时
给关键路径补齐自动测试
给关键路径补齐自动测试
这一步把任务 API 最容易出错的三条路径锁进自动测试:仓库读写、HTTP 处理器和并发访问。完成后可以用一次 go test -race 同时验证成功分支、未找到错误和共享状态是否存在数据竞争。
学习目标
- 用表驱动测试覆盖仓库的成功与错误分支。
- 用
httptest.NewServer从真实 HTTP 请求验证处理器状态码与响应体。 - 用
go test -race检查并发读写是否存在数据竞争。
先确定必须守住的关键路径
发布前不必追求每行代码都有测试,但任务 API 至少要守住三类风险:仓库返回错误时上层不能误报成功;HTTP 层必须把领域结果映射成稳定状态码;并发请求不能把共享 map 或自增 ID 写坏。下面的最小测试集正好对应这三类风险。

这里使用 Go 1.22+ 的方法路由模式 GET /tasks/{id} 与 Request.PathValue。如果项目仍在 Go 1.21,需要改成手工解析路径或使用项目现有路由器。
用一个测试文件覆盖仓库与 HTTP 层
在空目录保存下面的 task_test.go。示例把最小仓库和处理器放在测试文件里,便于独立运行;真实项目中应直接调用生产代码,而不是复制实现。
package taskapi_test
import (
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strconv"
"sync"
"testing"
)
var ErrNotFound = errors.New("task not found")
type task struct {
ID int
Title string
}
type repo struct {
mu sync.RWMutex
next int
data map[int]task
}
func newRepo() *repo {
return &repo{data: make(map[int]task)}
}
func (r *repo) Add(title string) task {
// 自增 ID 与 map 写入必须落在同一把锁内。
r.mu.Lock()
defer r.mu.Unlock()
r.next++
t := task{ID: r.next, Title: title}
r.data[t.ID] = t
return t
}
func (r *repo) Get(id int) (task, error) {
r.mu.RLock()
defer r.mu.RUnlock()
t, ok := r.data[id]
if !ok {
return task{}, ErrNotFound
}
return t, nil
}
func (r *repo) Count() int {
r.mu.RLock()
defer r.mu.RUnlock()
return len(r.data)
}
func newHandler(r *repo) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /tasks/{id}", func(w http.ResponseWriter, req *http.Request) {
id, err := strconv.Atoi(req.PathValue("id"))
if err != nil {
http.Error(w, "invalid task id", http.StatusBadRequest)
return
}
t, err := r.Get(id)
// 仓库的领域错误在 HTTP 边界映射为 404。
if errors.Is(err, ErrNotFound) {
http.Error(w, "task not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
fmt.Fprintf(w, `{"id":%d,"title":%q}`, t.ID, t.Title)
})
return mux
}
func TestRepoGet(t *testing.T) {
r := newRepo()
created := r.Add("ship release")
// 同一组输入同时覆盖成功与缺失两条仓库分支。
tests := []struct {
name string
id int
wantID int
wantErr bool
}{
{name: "found", id: created.ID, wantID: created.ID},
{name: "missing", id: 999, wantErr: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := r.Get(tt.id)
if tt.wantErr {
if !errors.Is(err, ErrNotFound) {
t.Fatalf("Get(%d) error = %v, want ErrNotFound", tt.id, err)
}
return
}
if err != nil || got.ID != tt.wantID {
t.Fatalf("Get(%d) = %+v, %v", tt.id, got, err)
}
})
}
}
func TestHTTPGet(t *testing.T) {
r := newRepo()
r.Add("ship release")
// NewServer 让请求真正经过 HTTP client、ServeMux 和 Handler。
srv := httptest.NewServer(newHandler(r))
defer srv.Close()
tests := []struct {
path string
wantStatus int
wantBody string
}{
{path: "/tasks/1", wantStatus: http.StatusOK, wantBody: `{"id":1,"title":"ship release"}`},
{path: "/tasks/999", wantStatus: http.StatusNotFound, wantBody: "task not found\n"},
}
for _, tt := range tests {
resp, err := srv.Client().Get(srv.URL + tt.path)
if err != nil {
t.Fatal(err)
}
body, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
t.Fatal(err)
}
if resp.StatusCode != tt.wantStatus || string(body) != tt.wantBody {
t.Fatalf("%s: status=%d body=%q", tt.path, resp.StatusCode, body)
}
}
}
func TestRepoConcurrentAccess(t *testing.T) {
r := newRepo()
r.Add("seed")
const workers = 32
var wg sync.WaitGroup
wg.Add(workers)
// 并发写入和读取共享同一 repo,交给 race detector 检查同步是否完整。
for i := 0; i < workers; i++ {
go func(i int) {
defer wg.Done()
r.Add(fmt.Sprintf("task-%d", i))
if _, err := r.Get(1); err != nil {
t.Errorf("Get(1): %v", err)
}
}(i)
}
wg.Wait()
if got, want := r.Count(), workers+1; got != want {
t.Fatalf("Count() = %d, want %d", got, want)
}
}预期结果
代码可被 Go 1.22+ 编译;三个测试分别覆盖仓库分支、HTTP 200/404 和 32 个并发访问者。用竞态检测器执行整组测试
先初始化模块,再开启竞态检测器。-race 会显著降低速度,因此它适合 CI、发布前检查或并发代码变更后的回归,不必作为每次保存文件后的最快测试命令。
go mod init example.com/taskapi >/dev/null 2>&1预期结果
命令成功时无输出,并在当前目录创建 go.mod。随后执行测试:
go test -race -v预期输出
=== RUN TestRepoGet
=== RUN TestRepoGet/found
=== RUN TestRepoGet/missing
--- PASS: TestRepoGet (<TIME>)
--- PASS: TestRepoGet/found (<TIME>)
--- PASS: TestRepoGet/missing (<TIME>)
=== RUN TestHTTPGet
--- PASS: TestHTTPGet (<TIME>)
=== RUN TestRepoConcurrentAccess
--- PASS: TestRepoConcurrentAccess (<TIME>)
PASS
ok example.com/taskapi <TIME><TIME> 会随机器和 Go 版本变化。若删掉 repo 上的互斥锁后再次执行,竞态检测器应报告 WARNING: DATA RACE;这类失败不能用“测试偶尔通过”忽略,因为普通测试通过并不代表共享内存访问安全。
把失败分支当成发布门槛
仓库测试至少要有一个明确的错误断言,例如 errors.Is(err, ErrNotFound);HTTP 测试则要同时断言状态码和正文,避免处理器只改了文字却意外把 404 变成 200。并发测试不要只看最终数量,还应始终带 -race 运行,否则互斥锁遗漏可能长期潜伏。
在真实项目中,可以把这三类测试分别放在仓库包、HTTP 包和集成测试目录中,但发布检查仍应保留一条统一命令,例如 go test -race ./...。只要这条命令失败,就不应继续构建发布物。