720 lines
17 KiB
Markdown
720 lines
17 KiB
Markdown
---
|
||
name: golang-testing
|
||
description: Go 語言測試模式，包含表驅動測試 (Table-Driven Tests)、子測試 (Subtests)、評測 (Benchmarks)、模糊測試 (Fuzzing) 以及測試覆蓋率。遵循道地的 Go 實踐與 TDD 方法論。
|
||
---
|
||
|
||
# Go 測試模式 (Go Testing Patterns)
|
||
|
||
綜合性的 Go 測試模式，遵循 TDD 方法論撰寫可靠且易於維護的測試。
|
||
|
||
## 何時啟用
|
||
|
||
- 撰寫新的 Go 函式或方法。
|
||
- 為現有程式碼增加測試覆蓋率。
|
||
- 為效能關鍵程式碼建立評測 (Benchmarks)。
|
||
- 為輸入驗證實作模糊測試 (Fuzz tests)。
|
||
- 在 Go 專案中遵循 TDD 工作流。
|
||
|
||
## Go 的 TDD 工作流
|
||
|
||
### 紅燈-綠燈-重構 週期 (RED-GREEN-REFACTOR Cycle)
|
||
|
||
```
|
||
紅燈 (RED) → 先撰寫一個會失敗的測試
|
||
綠燈 (GREEN) → 撰寫最少量的程式碼讓測試通過
|
||
重構 (REFACTOR) → 在保持測試綠燈的情況下優化程式碼
|
||
重複 (REPEAT) → 繼續下一個需求
|
||
```
|
||
|
||
### Go TDD 逐步示範
|
||
|
||
```go
|
||
// 步驟 1：定義介面/簽名
|
||
// calculator.go
|
||
package calculator
|
||
|
||
func Add(a, b int) int {
|
||
panic("尚未實作") // 佔位符
|
||
}
|
||
|
||
// 步驟 2：撰寫會失敗的測試 (紅燈)
|
||
// calculator_test.go
|
||
package calculator
|
||
|
||
import "testing"
|
||
|
||
func TestAdd(t *testing.T) {
|
||
got := Add(2, 3)
|
||
want := 5
|
||
if got != want {
|
||
t.Errorf("Add(2, 3) = %d; 期望為 %d", got, want)
|
||
}
|
||
}
|
||
|
||
// 步驟 3：執行測試 - 驗證失敗 (FAIL)
|
||
// $ go test
|
||
// --- FAIL: TestAdd (0.00s)
|
||
// panic: 尚未實作
|
||
|
||
// 步驟 4：實作最少量的程式碼 (綠燈)
|
||
func Add(a, b int) int {
|
||
return a + b
|
||
}
|
||
|
||
// 步驟 5：執行測試 - 驗證通過 (PASS)
|
||
// $ go test
|
||
// PASS
|
||
|
||
// 步驟 6：根據需要重構，驗證測試仍保持通過
|
||
```
|
||
|
||
## 表驅動測試 (Table-Driven Tests)
|
||
|
||
Go 測試的標準模式。能以最少的程式碼達成全面的覆蓋。
|
||
|
||
```go
|
||
func TestAdd(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
a, b int
|
||
expected int
|
||
}{
|
||
{"正數", 2, 3, 5},
|
||
{"負數", -1, -2, -3},
|
||
{"零值", 0, 0, 0},
|
||
{"正負混合", -1, 1, 0},
|
||
{"大數值", 1000000, 2000000, 3000000},
|
||
}
|
||
|
||
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; 期望為 %d",
|
||
tt.a, tt.b, got, tt.expected)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
### 包含錯誤案例的表驅動測試
|
||
|
||
```go
|
||
func TestParseConfig(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
input string
|
||
want *Config
|
||
wantErr bool
|
||
}{
|
||
{
|
||
name: "有效配置",
|
||
input: `{"host": "localhost", "port": 8080}`,
|
||
want: &Config{Host: "localhost", Port: 8080},
|
||
},
|
||
{
|
||
name: "無效 JSON",
|
||
input: `{invalid}`,
|
||
wantErr: true,
|
||
},
|
||
{
|
||
name: "空輸入",
|
||
input: "",
|
||
wantErr: true,
|
||
},
|
||
{
|
||
name: "最簡配置",
|
||
input: `{}`,
|
||
want: &Config{}, // 零值配置
|
||
},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got, err := ParseConfig(tt.input)
|
||
|
||
if tt.wantErr {
|
||
if err == nil {
|
||
t.Error("預期會發生錯誤，但回傳為 nil")
|
||
}
|
||
return
|
||
}
|
||
|
||
if err != nil {
|
||
t.Fatalf("發生非預期的錯誤: %v", err)
|
||
}
|
||
|
||
if !reflect.DeepEqual(got, tt.want) {
|
||
t.Errorf("得到 %+v; 期望為 %+v", got, tt.want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
## 子測試 (Subtests) 與子評測 (Sub-benchmarks)
|
||
|
||
### 組織相關聯的測試項
|
||
|
||
```go
|
||
func TestUser(t *testing.T) {
|
||
// 所有子測試共用的 Setup
|
||
db := setupTestDB(t)
|
||
|
||
t.Run("Create", func(t *testing.T) {
|
||
user := &User{Name: "Alice"}
|
||
err := db.CreateUser(user)
|
||
if err != nil {
|
||
t.Fatalf("建立使用者失敗: %v", err)
|
||
}
|
||
if user.ID == "" {
|
||
t.Error("預期應設定使用者 ID")
|
||
}
|
||
})
|
||
|
||
t.Run("Get", func(t *testing.T) {
|
||
user, err := db.GetUser("alice-id")
|
||
if err != nil {
|
||
t.Fatalf("獲取使用者失敗: %v", err)
|
||
}
|
||
if user.Name != "Alice" {
|
||
t.Errorf("得到名稱 %q; 期望為 %q", user.Name, "Alice")
|
||
}
|
||
})
|
||
|
||
t.Run("Update", func(t *testing.T) {
|
||
// ... 其他子測試
|
||
})
|
||
|
||
t.Run("Delete", func(t *testing.T) {
|
||
// ... 其他子測試
|
||
})
|
||
}
|
||
```
|
||
|
||
### 並行子測試
|
||
|
||
```go
|
||
func TestParallel(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
input string
|
||
}{
|
||
{"case1", "input1"},
|
||
{"case2", "input2"},
|
||
{"case3", "input3"},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
tt := tt // 捕捉迭代變數
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
t.Parallel() // 並行執行子測試
|
||
result := Process(tt.input)
|
||
// 斷言...
|
||
_ = result
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
## 測試輔助程式 (Test Helpers)
|
||
|
||
### 輔助函式
|
||
|
||
```go
|
||
func setupTestDB(t *testing.T) *sql.DB {
|
||
t.Helper() // 標記此函式為測試輔助程式
|
||
|
||
db, err := sql.Open("sqlite3", ":memory:")
|
||
if err != nil {
|
||
t.Fatalf("無法開啟資料庫: %v", err)
|
||
}
|
||
|
||
// 測試結束時自動清理
|
||
t.Cleanup(func() {
|
||
db.Close()
|
||
})
|
||
|
||
// 執行遷移
|
||
if _, err := db.Exec(schema); err != nil {
|
||
t.Fatalf("無法建立架構: %v", err)
|
||
}
|
||
|
||
return db
|
||
}
|
||
|
||
func assertNoError(t *testing.T, err error) {
|
||
t.Helper()
|
||
if err != nil {
|
||
t.Fatalf("發生非預期的錯誤: %v", err)
|
||
}
|
||
}
|
||
|
||
func assertEqual[T comparable](t *testing.T, got, want T) {
|
||
t.Helper()
|
||
if got != want {
|
||
t.Errorf("得到 %v; 期望為 %v", got, want)
|
||
}
|
||
}
|
||
```
|
||
|
||
### 臨時檔案與目錄
|
||
|
||
```go
|
||
func TestFileProcessing(t *testing.T) {
|
||
// 建立臨時目錄 - 測試結束後會自動清除
|
||
tmpDir := t.TempDir()
|
||
|
||
// 建立測試檔案
|
||
testFile := filepath.Join(tmpDir, "test.txt")
|
||
err := os.WriteFile(testFile, []byte("測試內容"), 0644)
|
||
if err != nil {
|
||
t.Fatalf("建立測試檔案失敗: %v", err)
|
||
}
|
||
|
||
// 執行測試
|
||
result, err := ProcessFile(testFile)
|
||
if err != nil {
|
||
t.Fatalf("執行 ProcessFile 失敗: %v", err)
|
||
}
|
||
|
||
// 斷言...
|
||
_ = result
|
||
}
|
||
```
|
||
|
||
## 黃金檔案 (Golden Files)
|
||
|
||
將預期的輸出儲存在 `testdata/` 目錄下的檔案中，並以此進行比對。
|
||
|
||
```go
|
||
var update = flag.Bool("update", false, "是否更新黃金檔案")
|
||
|
||
func TestRender(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
input Template
|
||
}{
|
||
{"simple", Template{Name: "test"}},
|
||
{"complex", Template{Name: "test", Items: []string{"a", "b"}}},
|
||
}
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
got := Render(tt.input)
|
||
|
||
golden := filepath.Join("testdata", tt.name+".golden")
|
||
|
||
if *update {
|
||
// 更新黃金檔案指令：go test -update
|
||
err := os.WriteFile(golden, got, 0644)
|
||
if err != nil {
|
||
t.Fatalf("更新黃金檔案失敗: %v", err)
|
||
}
|
||
}
|
||
|
||
want, err := os.ReadFile(golden)
|
||
if err != nil {
|
||
t.Fatalf("讀取黃金檔案失敗: %v", err)
|
||
}
|
||
|
||
if !bytes.Equal(got, want) {
|
||
t.Errorf("輸出不符：\n得到：\n%s\n期望：\n%s", got, want)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
## 使用介面進行 Mock
|
||
|
||
### 基於介面的 Mocking
|
||
|
||
```go
|
||
// 為依賴項定義介面
|
||
type UserRepository interface {
|
||
GetUser(id string) (*User, error)
|
||
SaveUser(user *User) error
|
||
}
|
||
|
||
// 生產環境的實作
|
||
type PostgresUserRepository struct {
|
||
db *sql.DB
|
||
}
|
||
|
||
func (r *PostgresUserRepository) GetUser(id string) (*User, error) {
|
||
// 實際的資料庫查詢
|
||
}
|
||
|
||
// 測試用的 Mock 實作
|
||
type MockUserRepository struct {
|
||
GetUserFunc func(id string) (*User, error)
|
||
SaveUserFunc func(user *User) error
|
||
}
|
||
|
||
func (m *MockUserRepository) GetUser(id string) (*User, error) {
|
||
return m.GetUserFunc(id)
|
||
}
|
||
|
||
func (m *MockUserRepository) SaveUser(user *User) error {
|
||
return m.SaveUserFunc(user)
|
||
}
|
||
|
||
// 使用 Mock 進行測試
|
||
func TestUserService(t *testing.T) {
|
||
mock := &MockUserRepository{
|
||
GetUserFunc: func(id string) (*User, error) {
|
||
if id == "123" {
|
||
return &User{ID: "123", Name: "Alice"}, nil
|
||
}
|
||
return nil, ErrNotFound
|
||
},
|
||
}
|
||
|
||
service := NewUserService(mock)
|
||
|
||
user, err := service.GetUserProfile("123")
|
||
if err != nil {
|
||
t.Fatalf("發生非預期的錯誤: %v", err)
|
||
}
|
||
if user.Name != "Alice" {
|
||
t.Errorf("得到名稱 %q; 期望為 %q", user.Name, "Alice")
|
||
}
|
||
}
|
||
```
|
||
|
||
## 評測 (Benchmarks)
|
||
|
||
### 基礎評測
|
||
|
||
```go
|
||
func BenchmarkProcess(b *testing.B) {
|
||
data := generateTestData(1000)
|
||
b.ResetTimer() // 排除 Setup 所耗費的時間
|
||
|
||
for i := 0; i < b.N; i++ {
|
||
Process(data)
|
||
}
|
||
}
|
||
|
||
// 執行指令：go test -bench=BenchmarkProcess -benchmem
|
||
// 輸出範例：BenchmarkProcess-8 10000 105234 ns/op 4096 B/op 10 allocs/op
|
||
```
|
||
|
||
### 不同規模的評測
|
||
|
||
```go
|
||
func BenchmarkSort(b *testing.B) {
|
||
sizes := []int{100, 1000, 10000, 100000}
|
||
|
||
for _, size := range sizes {
|
||
b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) {
|
||
data := generateRandomSlice(size)
|
||
b.ResetTimer()
|
||
|
||
for i := 0; i < b.N; i++ {
|
||
// 進行深拷貝以避免對已排序資料再次排序，從而準確評測
|
||
tmp := make([]int, len(data))
|
||
copy(tmp, data)
|
||
sort.Ints(tmp)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
### 記憶體配置評測 (Memory Allocation Benchmarks)
|
||
|
||
```go
|
||
func BenchmarkStringConcat(b *testing.B) {
|
||
parts := []string{"hello", "world", "foo", "bar", "baz"}
|
||
|
||
b.Run("plus", func(b *testing.B) {
|
||
for i := 0; i < b.N; i++ {
|
||
var s string
|
||
for _, p := range parts {
|
||
s += p
|
||
}
|
||
_ = s
|
||
}
|
||
})
|
||
|
||
b.Run("builder", func(b *testing.B) {
|
||
for i := 0; i < b.N; i++ {
|
||
var sb strings.Builder
|
||
for _, p := range parts {
|
||
sb.WriteString(p)
|
||
}
|
||
_ = sb.String()
|
||
}
|
||
})
|
||
|
||
b.Run("join", func(b *testing.B) {
|
||
for i := 0; i < b.N; i++ {
|
||
_ = strings.Join(parts, "")
|
||
}
|
||
})
|
||
}
|
||
```
|
||
|
||
## 模糊測試 (Fuzzing，Go 1.18+)
|
||
|
||
### 基礎模糊測試
|
||
|
||
```go
|
||
func FuzzParseJSON(f *testing.F) {
|
||
// 加入種子語料庫 (Seed corpus)
|
||
f.Add(`{"name": "test"}`)
|
||
f.Add(`{"count": 123}`)
|
||
f.Add(`[]`)
|
||
f.Add(`""`)
|
||
|
||
f.Fuzz(func(t *testing.T, input string) {
|
||
var result map[string]interface{}
|
||
err := json.Unmarshal([]byte(input), &result)
|
||
|
||
if err != nil {
|
||
// 對於隨機輸入，無效的 JSON 是可預期的
|
||
return
|
||
}
|
||
|
||
// 如果解析成功，則重新進行編碼應該也要成功
|
||
_, err = json.Marshal(result)
|
||
if err != nil {
|
||
t.Errorf("解析成功後 Marshal 卻失敗了: %v", err)
|
||
}
|
||
})
|
||
}
|
||
|
||
// 執行指令：go test -fuzz=FuzzParseJSON -fuzztime=30s
|
||
```
|
||
|
||
### 多輸入的模糊測試
|
||
|
||
```go
|
||
func FuzzCompare(f *testing.F) {
|
||
f.Add("hello", "world")
|
||
f.Add("", "")
|
||
f.Add("abc", "abc")
|
||
|
||
f.Fuzz(func(t *testing.T, a, b string) {
|
||
result := Compare(a, b)
|
||
|
||
// 屬性：Compare(a, a) 結果應永遠為 0
|
||
if a == b && result != 0 {
|
||
t.Errorf("Compare(%q, %q) = %d; 期望為 0", a, b, result)
|
||
}
|
||
|
||
// 屬性：Compare(a, b) 與 Compare(b, a) 應具備相反的正負號
|
||
reverse := Compare(b, a)
|
||
if (result > 0 && reverse >= 0) || (result < 0 && reverse <= 0) {
|
||
if result != 0 || reverse != 0 {
|
||
t.Errorf("Compare(%q, %q) = %d, Compare(%q, %q) = %d; 結果不一致",
|
||
a, b, result, b, a, reverse)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
```
|
||
|
||
## 測試覆蓋率 (Test Coverage)
|
||
|
||
### 執行覆蓋率檢查
|
||
|
||
```bash
|
||
# 基本覆蓋率檢查
|
||
go test -cover ./...
|
||
|
||
# 生成覆蓋率配置檔案
|
||
go test -coverprofile=coverage.out ./...
|
||
|
||
# 在瀏覽器中查看詳情
|
||
go tool cover -html=coverage.out
|
||
|
||
# 按函式查看覆蓋率
|
||
go tool cover -func=coverage.out
|
||
|
||
# 同時開啟 Race 偵測與覆蓋率檢查
|
||
go test -race -coverprofile=coverage.out ./...
|
||
```
|
||
|
||
### 覆蓋率目標
|
||
|
||
| 程式碼類型 | 目標百分比 |
|
||
|-----------|--------|
|
||
| 關鍵業務邏輯 | 100% |
|
||
| 公開 API | 90%+ |
|
||
| 一般程式碼 | 80%+ |
|
||
| 自動生成的程式碼 | 排除不計 |
|
||
|
||
### 從覆蓋率中排除自動產生的程式碼
|
||
|
||
```go
|
||
//go:generate mockgen -source=interface.go -destination=mock_interface.go
|
||
|
||
// 在執行覆蓋率檢查時，透過 Build Tags 排除：
|
||
// go test -cover -tags=!generate ./...
|
||
```
|
||
|
||
## HTTP Handler 測試
|
||
|
||
```go
|
||
func TestHealthHandler(t *testing.T) {
|
||
// 建立請求
|
||
req := httptest.NewRequest(http.MethodGet, "/health", nil)
|
||
w := httptest.NewRecorder()
|
||
|
||
// 呼叫 Handler
|
||
HealthHandler(w, req)
|
||
|
||
// 檢查回應
|
||
resp := w.Result()
|
||
defer resp.Body.Close()
|
||
|
||
if resp.StatusCode != http.StatusOK {
|
||
t.Errorf("得到狀態碼 %d; 期望為 %d", resp.StatusCode, http.StatusOK)
|
||
}
|
||
|
||
body, _ := io.ReadAll(resp.Body)
|
||
if string(body) != "OK" {
|
||
t.Errorf("得到回應文字 %q; 期望為 %q", body, "OK")
|
||
}
|
||
}
|
||
|
||
func TestAPIHandler(t *testing.T) {
|
||
tests := []struct {
|
||
name string
|
||
method string
|
||
path string
|
||
body string
|
||
wantStatus int
|
||
wantBody string
|
||
}{
|
||
{
|
||
name: "獲取使用者",
|
||
method: http.MethodGet,
|
||
path: "/users/123",
|
||
wantStatus: http.StatusOK,
|
||
wantBody: `{"id":"123","name":"Alice"}`,
|
||
},
|
||
{
|
||
name: "找不到資源",
|
||
method: http.MethodGet,
|
||
path: "/users/999",
|
||
wantStatus: http.StatusNotFound,
|
||
},
|
||
{
|
||
name: "建立使用者",
|
||
method: http.MethodPost,
|
||
path: "/users",
|
||
body: `{"name":"Bob"}`,
|
||
wantStatus: http.StatusCreated,
|
||
},
|
||
}
|
||
|
||
handler := NewAPIHandler()
|
||
|
||
for _, tt := range tests {
|
||
t.Run(tt.name, func(t *testing.T) {
|
||
var body io.Reader
|
||
if tt.body != "" {
|
||
body = strings.NewReader(tt.body)
|
||
}
|
||
|
||
req := httptest.NewRequest(tt.method, tt.path, body)
|
||
req.Header.Set("Content-Type", "application/json")
|
||
w := httptest.NewRecorder()
|
||
|
||
handler.ServeHTTP(w, req)
|
||
|
||
if w.Code != tt.wantStatus {
|
||
t.Errorf("得到狀態碼 %d; 期望為 %d", w.Code, tt.wantStatus)
|
||
}
|
||
|
||
if tt.wantBody != "" && w.Body.String() != tt.wantBody {
|
||
t.Errorf("得到回應內容 %q; 期望為 %q", w.Body.String(), tt.wantBody)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
## 常用測試指令
|
||
|
||
```bash
|
||
# 執行所有測試
|
||
go test ./...
|
||
|
||
# 執行測試並詳細輸出日誌
|
||
go test -v ./...
|
||
|
||
# 執行特定的測試項
|
||
go test -run TestAdd ./...
|
||
|
||
# 執行符合模式的測試項
|
||
go test -run "TestUser/Create" ./...
|
||
|
||
# 開啟 Race Detector (資源競爭偵測)
|
||
go test -race ./...
|
||
|
||
# 執行測試並產出覆蓋率報告
|
||
go test -cover -coverprofile=coverage.out ./...
|
||
|
||
# 僅執行標記為「短時」的測試
|
||
go test -short ./...
|
||
|
||
# 設定測試超時時間
|
||
go test -timeout 30s ./...
|
||
|
||
# 執行評測
|
||
go test -bench=. -benchmem ./...
|
||
|
||
# 執行模糊測試
|
||
go test -fuzz=FuzzParse -fuzztime=30s ./...
|
||
|
||
# 重複執行次數 (用於捕捉不穩定的測試)
|
||
go test -count=10 ./...
|
||
```
|
||
|
||
## 最佳實踐
|
||
|
||
**推薦做法 (DO)：**
|
||
- 先寫測試 (TDD)。
|
||
- 使用表驅動測試來達成全面覆蓋。
|
||
- 測試「行為」，而非測試「實作」。
|
||
- 在輔助函式中使用 `t.Helper()`。
|
||
- 對於彼此獨立的測試項使用 `t.Parallel()`。
|
||
- 使用 `t.Cleanup()` 來清理資源。
|
||
- 使用具備明確語義、能描述情境的測試名稱。
|
||
|
||
**應避免的做法 (DON'T)：**
|
||
- 直接測試私有函式 (應透過公開 API 進行測試)。
|
||
- 在測試中使用 `time.Sleep()` (應使用通道或同步條件)。
|
||
- 忽視不穩定的測試 (應修復或移除它們)。
|
||
- 對所有內容都進行 Mock (盡可能優先使用整合測試)。
|
||
- 遺漏錯誤路徑 (Error Path) 的測試。
|
||
|
||
## 與 CI/CD 整合
|
||
|
||
```yaml
|
||
# GitHub Actions 範例
|
||
test:
|
||
runs-on: ubuntu-latest
|
||
steps:
|
||
- uses: actions/checkout@v4
|
||
- uses: actions/setup-go@v5
|
||
with:
|
||
go-version: '1.22'
|
||
|
||
- name: 執行測試
|
||
run: go test -race -coverprofile=coverage.out ./...
|
||
|
||
- name: 檢查覆蓋率
|
||
run: |
|
||
go tool cover -func=coverage.out | grep total | awk '{print $3}' | \
|
||
awk -F'%' '{if ($1 < 80) exit 1}'
|
||
```
|
||
|
||
**請記住**：測試也是一種文件。它們展示了程式碼應如何被使用。請保持測試條理清晰並及時更新。
|