測試:表格驅動、httptest、整合測試
Testing in Go: Table-Driven Tests, httptest and Integration Tests
替訂單服務的每一層寫出合適的測試:用表格驅動測試涵蓋商業規則的邊界、用 httptest 不啟動伺服器就驗證 handler,再用建置標籤隔開連上真實資料庫的整合測試,驗證交易與防超賣真的有效。
這篇的步驟
上一篇〈database/sql、交易與連線池〉我們替訂單服務接上了資料庫,用交易與條件式更新防止超賣;這篇接著替前面寫好的每一層補上測試,讓這些「應該是對的」變成每次修改都能自動確認的事實。
這篇要解決什麼
到目前為止,我們確認程式正確的方式是手動用 curl 打幾個請求、看看回應對不對。這種做法有三個問題:它很慢,所以不會常做;它只檢查想得到的情況,邊界條件很容易被跳過;它無法在重構時保護你,改了一處,沒人知道另一處是否被弄壞。
Go 對測試的支援直接內建在工具鏈裡:不需要額外的測試框架,go test 加上標準函式庫的 testing 與 net/http/httptest 就能涵蓋絕大部分需求。這篇會依照訂單服務的分層,一層一層寫出對應的測試:
- 用表格驅動測試檢查計算總額這類純函式,系統化地列出所有邊界條件。
- 用手寫的替身取代相依物件,只測一層的邏輯。
- 用 httptest 在不開伺服器的情況下測試 handler 的路由、狀態碼與回應內容。
- 用整合測試連上真實資料庫,驗證交易的 Rollback 與併發下不會超賣。
- 最後整理讓測試快、穩定、可重複的習慣。
在開始之前,先看清楚各種測試的定位:
圖:越底層的測試越快、越穩定,應該佔多數;越上層越貼近真實,但數量應該較少。
這個「金字塔」不是硬性規定,而是一個成本取捨:單元測試幾毫秒就跑完、失敗時能精準指出問題;整合測試要準備資料庫、跑得慢,失敗時也比較難判斷是程式錯還是環境問題。好的策略是讓大部分邏輯在底層被驗證,上層只驗證「各部分接起來之後仍然正確」。〈分層架構與依賴注入〉把程式拆成小介面與可注入的相依物件,正是為了讓底層測試容易寫。
第 1 步:go test 的基本規則
Go 的測試有幾個簡單的約定:
- 測試檔名以
_test.go結尾,只在go test時編譯,不會進入正式的執行檔。 - 測試函式的名稱以
Test開頭,簽章是func TestXxx(t *testing.T)。 - 測試檔可以和被測程式同一個套件(
package order),能存取未公開的識別字;也可以用外部測試套件(package order_test),只能使用公開 API,從使用者的角度測試。兩者可以在同一個目錄並存。
*testing.T 上最常用的方法:
| 方法 | 作用 | 何時使用 |
|---|---|---|
t.Errorf | 記錄失敗,繼續執行 | 檢查多個獨立欄位時,一次看到所有錯誤 |
t.Fatalf | 記錄失敗,立刻結束這個測試 | 後續檢查已經沒有意義,例如解碼失敗就不必再比對內容 |
t.Run | 建立子測試 | 表格驅動測試的每一筆案例 |
t.Parallel | 標記可以和其他平行測試同時執行 | 互不共用可變狀態的測試 |
t.Helper | 標記為輔助函式 | 失敗訊息的行號會指向呼叫輔助函式的那一行 |
t.Cleanup | 註冊測試結束時執行的清理函式 | 關閉伺服器、資料庫連線、刪除暫存資料 |
t.Context | 取得測試專屬的 context(Go 1.24 起) | 測試結束前會自動被取消,傳給要 context 的函式 |
t.Skip | 略過這個測試 | 缺少必要的外部環境時 |
t.Fatalf 有一個重要限制:它只能在執行測試函式的那個 goroutine 裡呼叫。如果在自己開的 goroutine 裡呼叫,它只會結束那個 goroutine,測試本身不會停下。需要在 goroutine 裡回報錯誤時,把錯誤透過 channel 傳回主 goroutine 再判斷,第 5 步的併發測試就是這樣做的。
常用的指令:
go test ./... # 執行模組內所有套件的測試
go test ./internal/order -run TestTotal -v # 只跑符合名稱的測試,並顯示詳細輸出
go test ./internal/order -run 'TestTotal/discount' # 只跑某個子測試
go test -race -count=1 ./... # 開啟資料競爭偵測,並略過測試快取
go test -shuffle=on ./... # 隨機打亂測試順序,找出彼此相依的測試
go test -cover ./... # 顯示覆蓋率
go test -tags=integration ./... # 連同整合測試一起執行go test 會快取通過的結果:程式碼與測試都沒改時,第二次執行會直接顯示 (cached)。這在日常開發很方便,但如果測試依賴外部狀態(例如資料庫內容),用 -count=1 強制重新執行。
第 2 步:表格驅動測試
計算訂單總額是一個典型的純函式:輸入品項與折扣,輸出總額或錯誤,沒有任何副作用。這類函式最適合用表格驅動測試:把每個案例寫成表格中的一列,用同一段邏輯逐一驗證。先看被測的函式:
// 片段:internal/order/pricing.go
package order
import (
"errors"
"fmt"
)
var (
ErrNoItems = errors.New("order has no items")
ErrBadQuantity = errors.New("quantity must be positive")
ErrBadDiscount = errors.New("discount must be between 0 and 100")
)
type Item struct {
ProductID int64
Qty int
Price int64 // 單位:分
}
// Total 計算訂單總額;discountPct 是整數百分比,折扣後無條件捨去到分。
func Total(items []Item, discountPct int) (int64, error) {
if len(items) == 0 {
return 0, ErrNoItems
}
if discountPct < 0 || discountPct > 100 {
return 0, fmt.Errorf("%w: got %d", ErrBadDiscount, discountPct)
}
var sum int64
for _, it := range items {
if it.Qty <= 0 {
return 0, fmt.Errorf("product %d: %w", it.ProductID, ErrBadQuantity)
}
sum += it.Price * int64(it.Qty)
}
return sum * int64(100-discountPct) / 100, nil
}它有幾條需要被驗證的規則:沒有品項要回錯誤、數量必須為正、折扣必須介於 0 到 100、折扣後無條件捨去到分。對應的測試:
// internal/order/pricing_test.go
package order
import (
"errors"
"testing"
)
func TestTotal(t *testing.T) {
tests := []struct {
name string
items []Item
discount int
want int64
wantErr error
}{
{
name: "single item",
items: []Item{{ProductID: 1, Qty: 2, Price: 150}},
want: 300,
},
{
name: "discount rounds down",
items: []Item{{ProductID: 1, Qty: 1, Price: 999}},
discount: 15,
want: 849, // 999 * 0.85 = 849.15,捨去到 849
},
{
name: "full discount",
items: []Item{{ProductID: 1, Qty: 3, Price: 100}},
discount: 100,
want: 0,
},
{
name: "no items",
items: nil,
wantErr: ErrNoItems,
},
{
name: "zero quantity",
items: []Item{{ProductID: 1, Qty: 0, Price: 100}},
wantErr: ErrBadQuantity,
},
{
name: "discount over 100",
items: []Item{{ProductID: 1, Qty: 1, Price: 100}},
discount: 101,
wantErr: ErrBadDiscount,
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
got, err := Total(tc.items, tc.discount)
if !errors.Is(err, tc.wantErr) {
t.Fatalf("Total() error = %v, want %v", err, tc.wantErr)
}
if got != tc.want {
t.Errorf("Total() = %d, want %d", got, tc.want)
}
})
}
}為什麼用表格
- 新增案例的成本極低。 發現一個新的邊界條件時,只要在表格裡加一列,不用複製整段測試邏輯。這會鼓勵你把邊界都列出來:零、負數、剛好等於上限、超過上限一點點。
- 案例一眼可讀。 每一列都是「輸入是什麼、期望是什麼」,表格本身就是這個函式的規格說明。
- 子測試有名字。
t.Run(tc.name, ...)讓每個案例都是獨立的子測試,失敗訊息會顯示TestTotal/discount_rounds_down,也能用-run只重跑那一個。
幾個寫法細節
錯誤的比對方式。 表格裡的 wantErr 是哨兵錯誤,用 errors.Is(err, tc.wantErr) 比較。這個寫法很巧妙地同時涵蓋了兩種情況:期望成功時 wantErr 是 nil,errors.Is(nil, nil) 為真,而如果實際回傳了錯誤,errors.Is(err, nil) 為假,測試就會失敗。期望特定錯誤時,即使 Total 用 %w 包上了額外的脈絡,errors.Is 仍然能辨識出來。這正是〈錯誤處理:包裝、哨兵、自訂型別〉強調用哨兵錯誤與 %w 的實際回報:測試不必比對錯誤訊息字串,訊息措辭改了測試也不會壞。
平行執行。 子測試裡呼叫 t.Parallel(),各案例就會同時執行。Go 1.22 起每次迴圈的變數都是新的,所以不再需要舊版那句 tc := tc;但要確定案例之間真的沒有共用可變狀態。
失敗訊息要能自我說明。 好的失敗訊息格式是「呼叫了什麼、得到什麼、期望什麼」,例如 Total() = 850, want 849。看到這一行就知道問題在哪,不用重新執行加印除錯訊息。
比較複雜的結構。 範例用 != 比較整數就夠了。比較結構體時,只要所有欄位都可比較,也能直接用 ==;含 slice 或 map 的結構體可以用 reflect.DeepEqual,或社群常用的 github.com/google/go-cmp/cmp,它能印出兩者的差異,失敗時更容易看懂。
提示:表格中期望值的註解(例如
999 * 0.85 = 849.15,捨去到 849)很有價值。它記錄了「為什麼期望是這個數字」,未來有人懷疑規則時,不必重新推導一次。
第 3 步:用替身隔開相依物件
service 依賴 repository,handler 依賴 service。要只測其中一層,就必須把它的相依物件換成替身(test double)。在 Go 裡,替身通常是手寫的,因為介面已經由使用方定義、而且很小:
| 替身種類 | 行為 | 範例 |
|---|---|---|
| stub | 回傳事先準備好的固定結果 | 永遠回傳某筆訂單或某個錯誤 |
| fake | 有簡化但可運作的實作 | 用 map 模擬儲存,能存能讀 |
| spy | 記錄自己被怎麼呼叫,事後檢查 | 記下 Create 收到的訂單 |
| mock | 事先設定期望的呼叫,不符就失敗 | 通常由工具產生 |
上一篇已經示範過用 stub 測 service:替身記住被存入的訂單,再加上一個回傳固定時間的時鐘函式,就能精準驗證總額、狀態與建立時間。這一篇的 handler 測試則用一個 fake:以 map 模擬資料,並可以設定成一律回傳某個錯誤,用來模擬資料庫故障。
手寫替身與 mock 產生工具各有取捨。手寫替身的程式碼一目了然,測試讀起來就像在描述行為;mock 工具適合需要精確驗證「某方法被呼叫幾次、參數是什麼」的情況,但測試容易和實作細節綁太緊,重構時即使行為沒變,測試也要大改。一般建議優先驗證結果,而不是驗證呼叫過程:與其檢查「repository 的 Create 被呼叫了一次」,不如檢查「之後 Get 得到的訂單是對的」。
另外兩個在寫替身與輔助函式時常用的工具:
t.Helper():在輔助函式開頭呼叫,失敗時的行號會指向測試裡呼叫它的那一行,而不是輔助函式內部,否則所有失敗都會顯示在同一個輔助函式的行號上,很難找出是哪個案例。t.Cleanup(f):註冊清理動作,在測試(包含所有子測試)結束後依「後進先出」的順序執行。比起defer,它的好處是可以寫在輔助函式裡:輔助函式建立資源、順手註冊清理,呼叫者完全不用管。
第 4 步:用 httptest 測試 handler
handler 的職責是 HTTP 的翻譯工作:路徑參數能不能正確解析、錯誤有沒有被翻成正確的狀態碼、回應的標頭與本文格式對不對。這些都可以在不啟動伺服器的情況下測試。為了讓範例聚焦,這裡用一個只有查詢端點的精簡版 handler:
// 片段:internal/order/handler.go(本篇用的精簡版)
package order
import (
"context"
"encoding/json"
"errors"
"net/http"
"strconv"
)
var ErrNotFound = errors.New("order not found")
type Order struct {
ID int64 `json:"id"`
UserID int64 `json:"user_id"`
Total int64 `json:"total"`
Status string `json:"status"`
}
// Finder 是 handler 需要的最小能力,測試時換成假的實作。
type Finder interface {
Get(ctx context.Context, id int64) (Order, error)
}
func NewHandler(f Finder) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /orders/{id}", func(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
if err != nil {
http.Error(w, "id must be a number", http.StatusBadRequest)
return
}
o, err := f.Get(r.Context(), id)
switch {
case errors.Is(err, ErrNotFound):
http.Error(w, "order not found", http.StatusNotFound)
return
case err != nil:
http.Error(w, "internal error", http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json; charset=utf-8")
_ = json.NewEncoder(w).Encode(o)
})
return mux
}注意 NewHandler 回傳的是包含路由的 http.Handler,而不只是一個 handler 函式。這很重要:r.PathValue("id") 的值是由 ServeMux 比對模式時填入的,如果測試直接呼叫內部的 handler 函式、繞過了 mux,PathValue 會拿到空字串。透過 mux 測試,也順便驗證了路由模式本身寫對了,包括錯誤方法會不會回 405。(如果真的需要單獨測某個 handler 函式,可以在請求上呼叫 req.SetPathValue("id", "42") 手動填值。)
net/http/httptest 提供了兩種測試方式:
圖:NewRecorder 把 handler 當成普通函式直接呼叫;NewServer 在本機隨機埠啟動真的伺服器,連同用戶端行為一起驗證。
NewRecorder:最快、最常用
httptest.NewRecorder() 回傳一個實作了 http.ResponseWriter 的記錄器,handler 寫入的狀態碼、標頭與本文都會被保存下來。配合 httptest.NewRequest(或 Go 1.23 起可以直接帶 context 的 httptest.NewRequestWithContext)建立請求,就能直接呼叫 ServeHTTP:
// internal/order/handler_test.go
package order
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"testing"
)
// fakeFinder 用 map 模擬資料,err 不為 nil 時一律回傳該錯誤。
type fakeFinder struct {
orders map[int64]Order
err error
}
func (f fakeFinder) Get(_ context.Context, id int64) (Order, error) {
if f.err != nil {
return Order{}, f.err
}
o, ok := f.orders[id]
if !ok {
return Order{}, ErrNotFound
}
return o, nil
}
func TestGetOrder(t *testing.T) {
finder := fakeFinder{orders: map[int64]Order{
42: {ID: 42, UserID: 7, Total: 300, Status: "pending"},
}}
tests := []struct {
name string
finder Finder
method string
path string
wantStatus int
}{
{"found", finder, http.MethodGet, "/orders/42", http.StatusOK},
{"not found", finder, http.MethodGet, "/orders/99", http.StatusNotFound},
{"bad id", finder, http.MethodGet, "/orders/abc", http.StatusBadRequest},
{"wrong method", finder, http.MethodDelete, "/orders/42", http.StatusMethodNotAllowed},
{"store failure", fakeFinder{err: errors.New("db down")}, http.MethodGet, "/orders/42", http.StatusInternalServerError},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
req := httptest.NewRequestWithContext(t.Context(), tc.method, tc.path, nil)
rec := httptest.NewRecorder()
NewHandler(tc.finder).ServeHTTP(rec, req)
if rec.Code != tc.wantStatus {
t.Fatalf("status = %d, want %d; body = %q", rec.Code, tc.wantStatus, rec.Body.String())
}
})
}
t.Run("response body", func(t *testing.T) {
rec := httptest.NewRecorder()
NewHandler(finder).ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/orders/42", nil))
var got Order
if err := json.NewDecoder(rec.Body).Decode(&got); err != nil {
t.Fatalf("decode body: %v", err)
}
if want := (Order{ID: 42, UserID: 7, Total: 300, Status: "pending"}); got != want {
t.Errorf("body = %+v, want %+v", got, want)
}
if ct := rec.Header().Get("Content-Type"); ct != "application/json; charset=utf-8" {
t.Errorf("Content-Type = %q", ct)
}
})
}
// 透過真正的 TCP 連線測試,連同 http.Client 的行為一起驗證。
func TestGetOrderOverNetwork(t *testing.T) {
srv := httptest.NewServer(NewHandler(fakeFinder{orders: map[int64]Order{
1: {ID: 1, UserID: 8, Total: 100, Status: "paid"},
}}))
t.Cleanup(srv.Close)
req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, srv.URL+"/orders/1", nil)
if err != nil {
t.Fatal(err)
}
resp, err := srv.Client().Do(req)
if err != nil {
t.Fatalf("request: %v", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("status = %d, want 200", resp.StatusCode)
}
}這個測試檔包含三個部分:
- 表格驅動的狀態碼測試。 找得到、找不到、id 不是數字、方法不對、儲存層故障,每一種情況都應該對應到正確的狀態碼。特別是「儲存層故障回 500」這個案例,只有用替身才能輕易製造出來;用真實資料庫要模擬故障可就麻煩多了。
- 回應內容的測試。 把本文解碼回
Order結構體再比較,而不是比對 JSON 字串。字串比對會因為欄位順序、空白、結尾換行而失敗,結構體比對只關心真正重要的內容。同時檢查Content-Type標頭。 - 透過網路的測試。 見下一小節。
NewServer:需要真的連線時
httptest.NewServer(handler) 會在 127.0.0.1 的隨機埠上啟動一個真的 HTTP 伺服器,srv.URL 是它的位址,srv.Client() 回傳設定好的用戶端。它比 Recorder 慢一點,但能驗證只有真實連線才會出現的行為:中介層對真實請求的處理、壓縮、重新導向、連線逾時、TLS(用 NewTLSServer)等。用 t.Cleanup(srv.Close) 確保測試結束時伺服器被關閉。
NewServer 還有一個很實用的用途:模擬外部服務。訂單服務之後會呼叫支付服務,測試時可以用 NewServer 起一個假的支付服務,回傳預先準備好的回應,甚至故意延遲或回 503,測試呼叫端的逾時與錯誤處理。〈逾時、重試與熔斷〉會大量用到這個技巧。
第 5 步:連上真實資料庫的整合測試
替身能證明「各層的邏輯正確」,卻無法證明「SQL 寫對了」、「交易真的會 Rollback」、「條件式更新在併發下真的不會超賣」。這些只有在真實資料庫上執行才能驗證,也就是整合測試。
整合測試需要外部環境,跑得也比較慢,所以通常和單元測試分開:平常開發時 go test ./... 只跑快速的單元測試,CI 或需要時才加上整合測試。Go 有兩種常見的隔離方式:
| 方式 | 寫法 | 特性 |
|---|---|---|
| 建置標籤 | 檔案開頭 //go:build integration,用 -tags=integration 執行 | 沒加標籤時整個檔案不編譯,連驅動程式都不會被引入 |
testing.Short() | 測試開頭 if testing.Short() { t.Skip() },用 -short 略過 | 檔案一直會編譯,預設會跑,要主動加 -short 才略過 |
本文採用建置標籤,並且在測試裡再加一道保險:沒有設定 TEST_DATABASE_URL 環境變數時直接 t.Skip,而不是失敗。這樣即使有人加了標籤卻沒準備資料庫,看到的是清楚的「略過」訊息。
// 片段:internal/order/repository_integration_test.go
//go:build integration
package order
import (
"database/sql"
"errors"
"os"
"sync"
"testing"
_ "github.com/jackc/pgx/v5/stdlib" // 只有整合測試需要真的驅動程式
)
func openTestDB(t *testing.T) *sql.DB {
t.Helper()
dsn := os.Getenv("TEST_DATABASE_URL")
if dsn == "" {
t.Skip("TEST_DATABASE_URL 未設定,略過整合測試")
}
db, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatalf("open db: %v", err)
}
t.Cleanup(func() { db.Close() })
if err := db.PingContext(t.Context()); err != nil {
t.Fatalf("ping db: %v", err)
}
return db
}
// seed 清空資料表,放入一個庫存只有 stock 件的商品。
func seed(t *testing.T, db *sql.DB, stock int) {
t.Helper()
ctx := t.Context()
if _, err := db.ExecContext(ctx,
`TRUNCATE order_items, orders, products RESTART IDENTITY CASCADE`); err != nil {
t.Fatalf("truncate: %v", err)
}
if _, err := db.ExecContext(ctx,
`INSERT INTO products (id, name, price, stock) VALUES (1, 'mug', 350, $1)`, stock); err != nil {
t.Fatalf("insert product: %v", err)
}
}
func countOrders(t *testing.T, db *sql.DB) int {
t.Helper()
var n int
if err := db.QueryRowContext(t.Context(), `SELECT count(*) FROM orders`).Scan(&n); err != nil {
t.Fatalf("count orders: %v", err)
}
return n
}
func TestPlaceOrder_OutOfStockRollsBack(t *testing.T) {
db := openTestDB(t)
seed(t, db, 1)
repo := NewOrderRepo(db)
if _, err := repo.PlaceOrder(t.Context(), 7, []Item{{ProductID: 1, Qty: 1}}); err != nil {
t.Fatalf("first order: %v", err)
}
_, err := repo.PlaceOrder(t.Context(), 8, []Item{{ProductID: 1, Qty: 1}})
if !errors.Is(err, ErrOutOfStock) {
t.Fatalf("second order: error = %v, want ErrOutOfStock", err)
}
if got := countOrders(t, db); got != 1 {
t.Errorf("orders = %d, want 1", got)
}
}
func TestPlaceOrder_NoOversellUnderConcurrency(t *testing.T) {
db := openTestDB(t)
seed(t, db, 1)
repo := NewOrderRepo(db)
const buyers = 20
var wg sync.WaitGroup
errs := make(chan error, buyers)
for i := range buyers {
wg.Add(1)
go func() {
defer wg.Done()
_, err := repo.PlaceOrder(t.Context(), int64(100+i), []Item{{ProductID: 1, Qty: 1}})
errs <- err
}()
}
wg.Wait()
close(errs)
var ok, outOfStock int
for err := range errs {
switch {
case err == nil:
ok++
case errors.Is(err, ErrOutOfStock):
outOfStock++
default:
t.Errorf("unexpected error: %v", err)
}
}
if ok != 1 || outOfStock != buyers-1 {
t.Errorf("ok = %d, outOfStock = %d; want 1 and %d", ok, outOfStock, buyers-1)
}
if got := countOrders(t, db); got != 1 {
t.Errorf("orders = %d, want 1", got)
}
}這兩個測試在驗證什麼
TestPlaceOrder_OutOfStockRollsBack:商品庫存只有 1 件。第一筆訂單應該成功;第二筆應該回 ErrOutOfStock,而且最重要的是,資料庫裡只能有 1 筆訂單。這直接驗證了上一篇交易的承諾:失敗的下單不會留下任何殘留資料。
TestPlaceOrder_NoOversellUnderConcurrency:20 個 goroutine 同時搶購唯一的 1 件商品。如果扣庫存的寫法是「先讀後寫」,這個測試很可能會看到多筆訂單成功;用條件式更新時,結果必須剛好是 1 筆成功、19 筆庫存不足。注意 goroutine 裡沒有呼叫 t.Fatalf,而是把錯誤送進 channel,由主 goroutine 統一判斷。數字 20 只是示意,重點是「同時」。
這類測試的價值在於:它把「不會超賣」從一個信念,變成每次 CI 都會被檢查的事實。哪天有人為了效能重寫扣庫存的邏輯,這個測試會立刻告訴他是否破壞了正確性。
每個測試都從乾淨的狀態開始
整合測試最常見的不穩定來源,是測試之間共用資料。範例的 seed 在每個測試開頭清空資料表並放入固定資料,確保測試不受執行順序影響。常見的隔離策略有:
- 每個測試開頭清空並重新放入資料(本文的做法):簡單直接,但同一個資料庫上的測試不能平行執行。
- 每個測試包在一個交易裡,結束時 Rollback:速度快,但被測程式碼本身也要開交易時就不適用,像
PlaceOrder這種情況。 - 每個測試(或每個套件)使用獨立的資料庫或 schema:可以平行,但準備成本較高。
資料庫本身可以用 Docker 在本機或 CI 啟動,表結構用與正式環境相同的遷移檔建立,確保測試的 schema 與正式環境一致。〈用 Docker Compose 部署整套微服務〉會把資料庫與各服務一起用 Compose 啟動;社群也有在測試程式碼裡直接控制容器生命週期的套件,例如 testcontainers-go。
提示:
t.Context()回傳的 context 會在測試結束、清理函式執行之前被取消。把它傳給資料庫呼叫,測試逾時或被中斷時,進行中的查詢也會跟著停下,不會留下卡住的連線。
第 6 步:讓測試快、穩定、值得信任
測試寫出來之後,還要讓它長期可信。一套偶爾失敗的測試,最後會被所有人忽略。
一定要開 -race
go test -race 會開啟資料競爭偵測器,在執行期間抓出多個 goroutine 未經同步就存取同一個變數的情況。HTTP handler 本來就在多個 goroutine 中執行,加上平行子測試與併發測試,-race 能抓到大量肉眼看不出來的問題。它會讓測試變慢數倍,但在 CI 上應該一直開著。偵測器只能抓到「實際執行到」的競爭,所以有併發情境的測試(如第 5 步的搶購測試)搭配 -race 特別有價值。
不要依賴時間與順序
- 不要用
time.Sleep等待非同步結果。 機器忙碌時睡不夠就失敗,睡太久又拖慢整套測試。改用 channel、sync.WaitGroup等明確的同步方式。對大量依賴計時器與逾時的程式碼,Go 1.25 起的testing/synctest提供了虛擬時鐘,能讓這類測試瞬間完成而且結果確定。 - 把時間注入。 如上一篇的
now func() time.Time,讓「現在」成為可控的輸入。 - 用
-shuffle=on找出順序相依。 某個測試只有在另一個測試之後執行才會通過,代表它們偷偷共用了狀態。
覆蓋率是參考,不是目標
go test -coverprofile=cover.out ./... 搭配 go tool cover -html=cover.out 可以看到哪些程式碼沒被執行過。它最有用的地方是找出完全沒測到的錯誤處理分支。但覆蓋率高不代表測試好:一個只呼叫函式、不檢查結果的測試也能拉高覆蓋率。與其追求某個百分比,不如確認每條重要的商業規則與每個錯誤對應都有測試。
其他值得知道的工具
- 黃金檔案(golden file):輸出很長時(例如產生的報表或複雜 JSON),把期望輸出存在
testdata/目錄下的檔案裡比較,搭配一個-update旗標重新產生。go工具會忽略testdata目錄,適合放測試資料。 - 模糊測試(fuzzing):
func FuzzXxx(f *testing.F)讓 Go 自動產生大量隨機輸入,適合解析器、驗證函式這類要處理任意輸入的程式碼。 - 基準測試:
func BenchmarkXxx(b *testing.B)量測效能,會在〈效能調校:pprof 與 benchmark〉詳細介紹。
在 CI 上的組合
一個常見的 CI 流程是:先跑 go vet ./... 與單元測試 go test -race ./...,這一段應該在很短時間內完成,給開發者快速回饋;接著啟動資料庫容器、執行遷移,再跑 go test -race -tags=integration -count=1 ./...。兩段分開,單元測試失敗時就不必浪費時間準備資料庫。
常見陷阱
- 在 goroutine 裡呼叫
t.Fatal。 只會結束那個 goroutine,測試繼續跑甚至誤判為通過;把錯誤傳回主 goroutine 再判斷。 - 繞過 mux 直接測 handler 函式。
r.PathValue會是空字串,路由模式寫錯也測不出來;透過NewHandler回傳的 mux 測試,或手動SetPathValue。 - 比對錯誤訊息字串。 訊息措辭一改測試就壞;用
errors.Is、errors.As比對錯誤的身分。 - 比對 JSON 字串。 欄位順序或空白不同就失敗;解碼回結構體再比較。
- 用
time.Sleep等待。 測試變慢又不穩定;改用明確的同步,或注入時間。 - 整合測試共用資料。 測試之間互相影響,只在特定順序下通過;每個測試從乾淨的狀態開始。
- 只有替身測試,沒有整合測試。 替身完全照著你的假設運作,SQL 寫錯、交易沒包好都測不出來;關鍵的資料庫行為一定要有整合測試。
- mock 驗證過多呼叫細節。 行為沒變、只是重構了實作,測試就大量失敗;優先驗證結果。
- 忘了關閉資源。 測試伺服器、資料庫連線沒關,測試數量一多就耗盡檔案描述子;用
t.Cleanup。 - 沒開
-race。 並發錯誤在本機看起來都正常,上線後偶爾出現難以重現的錯誤。
重點整理
go test內建於工具鏈:測試檔以_test.go結尾,測試函式為TestXxx(t *testing.T);t.Errorf繼續執行、t.Fatalf立刻結束。- 測試金字塔:大量快速的單元測試,適量的 handler 測試,少量但關鍵的整合測試。
- 表格驅動測試讓新增邊界案例的成本極低;用
t.Run建立具名子測試,用errors.Is比對錯誤。 - 小介面讓手寫替身變得簡單;優先驗證結果,而不是呼叫過程;輔助函式用
t.Helper,資源用t.Cleanup。 httptest.NewRecorder直接呼叫 handler,最快;透過 mux 測試才能取得PathValue並驗證路由與 405。httptest.NewServer提供真的連線,也適合用來模擬外部服務。- 整合測試用建置標籤
//go:build integration隔開,缺少環境時t.Skip;每個測試從乾淨的資料開始,驗證 Rollback 與併發不超賣。 - 用
t.Context()取得會在測試結束時取消的 context;CI 上一律加-race,用-shuffle=on找出順序相依。
下一篇
到這裡,訂單服務已經是一個有路由、分層、資料庫與測試的完整服務。接下來的問題是:當商店長出支付、庫存等更多功能,要不要把它們拆成獨立的服務、又該沿著哪條線拆?〈什麼時候該拆:邊界與拆分策略〉會從這個單一服務出發,討論拆分的時機與邊界。