Go / 系统课时

给关键路径补齐自动测试

给关键路径补齐自动测试

这一步把任务 API 最容易出错的三条路径锁进自动测试:仓库读写、HTTP 处理器和并发访问。完成后可以用一次 go test -race 同时验证成功分支、未找到错误和共享状态是否存在数据竞争。

学习目标

  • 用表驱动测试覆盖仓库的成功与错误分支。
  • 用 httptest.NewServer 从真实 HTTP 请求验证处理器状态码与响应体。
  • 用 go test -race 检查并发读写是否存在数据竞争。

先确定必须守住的关键路径

发布前不必追求每行代码都有测试,但任务 API 至少要守住三类风险:仓库返回错误时上层不能误报成功;HTTP 层必须把领域结果映射成稳定状态码;并发请求不能把共享 map 或自增 ID 写坏。下面的最小测试集正好对应这三类风险。

关键路径测试从仓库到 HTTP 与并发访问的覆盖关系

这里使用 Go 1.22+ 的方法路由模式 GET /tasks/{id} 与 Request.PathValue。如果项目仍在 Go 1.21,需要改成手工解析路径或使用项目现有路由器。

用一个测试文件覆盖仓库与 HTTP 层

在空目录保存下面的 task_test.go。示例把最小仓库和处理器放在测试文件里,便于独立运行;真实项目中应直接调用生产代码,而不是复制实现。

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)
	}
}

预期结果

text
代码可被 Go 1.22+ 编译;三个测试分别覆盖仓库分支、HTTP 200/404 和 32 个并发访问者。

用竞态检测器执行整组测试

先初始化模块,再开启竞态检测器。-race 会显著降低速度,因此它适合 CI、发布前检查或并发代码变更后的回归,不必作为每次保存文件后的最快测试命令。

bash
go mod init example.com/taskapi >/dev/null 2>&1

预期结果

text
命令成功时无输出,并在当前目录创建 go.mod。

随后执行测试:

bash
go test -race -v

预期输出

text
=== 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 ./...。只要这条命令失败,就不应继续构建发布物。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

给关键路径补齐自动测试

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通