This resume is also available in English.

二、寫一個服務第 4 / 4 篇 · 全部目錄

專欄 › 二、寫一個服務 › 第 8 篇

測試:表格驅動、httptest、整合測試

Testing in Go: Table-Driven Tests, httptest and Integration Tests

替訂單服務的每一層寫出合適的測試:用表格驅動測試涵蓋商業規則的邊界、用 httptest 不啟動伺服器就驗證 handler,再用建置標籤隔開連上真實資料庫的整合測試,驗證交易與防超賣真的有效。

  • Go
  • Testing
  • httptest
  • Integration Testing
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:go test 的基本規則
  3. 第 2 步:表格驅動測試
  4. 第 3 步:用替身隔開相依物件
  5. 第 4 步:用 httptest 測試 handler
  6. 第 5 步:連上真實資料庫的整合測試
  7. 第 6 步:讓測試快、穩定、值得信任
  8. 常見陷阱
  9. 重點整理
  10. 下一篇

上一篇〈database/sql、交易與連線池〉我們替訂單服務接上了資料庫,用交易與條件式更新防止超賣;這篇接著替前面寫好的每一層補上測試,讓這些「應該是對的」變成每次修改都能自動確認的事實。

這篇要解決什麼

到目前為止,我們確認程式正確的方式是手動用 curl 打幾個請求、看看回應對不對。這種做法有三個問題:它很慢,所以不會常做;它只檢查想得到的情況,邊界條件很容易被跳過;它無法在重構時保護你,改了一處,沒人知道另一處是否被弄壞。

Go 對測試的支援直接內建在工具鏈裡:不需要額外的測試框架,go test 加上標準函式庫的 testing 與 net/http/httptest 就能涵蓋絕大部分需求。這篇會依照訂單服務的分層,一層一層寫出對應的測試:

  • 用表格驅動測試檢查計算總額這類純函式,系統化地列出所有邊界條件。
  • 用手寫的替身取代相依物件,只測一層的邏輯。
  • 用 httptest 在不開伺服器的情況下測試 handler 的路由、狀態碼與回應內容。
  • 用整合測試連上真實資料庫,驗證交易的 Rollback 與併發下不會超賣。
  • 最後整理讓測試快、穩定、可重複的習慣。

在開始之前,先看清楚各種測試的定位:

端對端測試 整套服務,最少、最慢 整合測試 真的資料庫,-tags=integration handler 測試 httptest,用替身取代 service 單元測試 純函式與 service,毫秒級完成,數量最多 越往下:越快、越穩定、數量越多 越往上:越貼近真實環境,但越慢、越容易受外部因素影響

圖:越底層的測試越快、越穩定,應該佔多數;越上層越貼近真實,但數量應該較少。

這個「金字塔」不是硬性規定,而是一個成本取捨:單元測試幾毫秒就跑完、失敗時能精準指出問題;整合測試要準備資料庫、跑得慢,失敗時也比較難判斷是程式錯還是環境問題。好的策略是讓大部分邏輯在底層被驗證,上層只驗證「各部分接起來之後仍然正確」。〈分層架構與依賴注入〉把程式拆成小介面與可注入的相依物件,正是為了讓底層測試容易寫。

第 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:直接呼叫,不經過網路 測試函式 NewRecorder 當作 ResponseWriter handler.ServeHTTP 結束後直接讀 rec.Code、rec.Header()、rec.Body NewServer:真的 TCP 連線到本機隨機埠 測試函式 http.Client NewServer 127.0.0.1:隨機埠 handler 連同標頭編碼、重新導向、逾時、TLS 等用戶端行為一起驗證

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

這個測試檔包含三個部分:

  1. 表格驅動的狀態碼測試。 找得到、找不到、id 不是數字、方法不對、儲存層故障,每一種情況都應該對應到正確的狀態碼。特別是「儲存層故障回 500」這個案例,只有用替身才能輕易製造出來;用真實資料庫要模擬故障可就麻煩多了。
  2. 回應內容的測試。 把本文解碼回 Order 結構體再比較,而不是比對 JSON 字串。字串比對會因為欄位順序、空白、結尾換行而失敗,結構體比對只關心真正重要的內容。同時檢查 Content-Type 標頭。
  3. 透過網路的測試。 見下一小節。

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 找出順序相依。

下一篇

到這裡,訂單服務已經是一個有路由、分層、資料庫與測試的完整服務。接下來的問題是:當商店長出支付、庫存等更多功能,要不要把它們拆成獨立的服務、又該沿著哪條線拆?〈什麼時候該拆:邊界與拆分策略〉會從這個單一服務出發,討論拆分的時機與邊界。