HttpTest
回忆我们编写的Handler
func healthz(w http.ResponseWriter,r *http.Request)goHandler 通过 r 读取请求,通过 w 写出响应。
httptest.NewRecorder() 创建一个实现了 http.ResponseWriter 的响应记录器,将 Handler 写出的状态码、响应头和响应体保存在内存中;httptest.NewRequest() 则构造供服务端处理的 HTTP 请求。因此,测试可以直接调用 Handler,不必先监听端口。
// 位于 net/http/httptest 包中,通过 httptest.NewRequest 调用。
func NewRequest(method string, target string, body io.Reader) *http.Requestgo第一个参数是 HTTP 方法,第二个参数是请求目标(如 /target),第三个参数是请求体。请求体需要是实现了 io.Reader 接口的值;没有请求体时可以传 nil。例如:
strings.NewReader(`{"name":"demo"}`) // 输入为 string
bytes.NewReader([]byte(`{"name":"demo"}`)) // 输入为 []bytego这两个函数返回的值都实现了 io.Reader,可以作为请求体参数;不能直接把 string 或 []byte 传给 NewRequest 的第三个参数。io.Reader 是接口,不是方法。
下面是一个简单实例:
package main
import (
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
)
func TestHealthz(t *testing.T) {
// 1. 准备请求和响应记录器
req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
rec := httptest.NewRecorder()
// 2. 执行被测代码
healthz(rec, req)
// 3. 检查响应状态
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want %d; body = %s",
rec.Code, http.StatusOK, rec.Body.String())
}
// 4. 检查响应头
if got := rec.Header().Get("Content-Type"); got != "application/json" {
t.Errorf("Content-Type = %q, want application/json", got)
}
// 5. 解析并检查 JSON 内容
var body struct {
Status string `json:"status"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if body.Status != "ok" {
t.Errorf("status field = %q, want ok", body.Status)
}
}go一些需要注意的点
反序列化不会自动清空旧结构体。
对当前 encoding/json 的普通结构体解析,JSON 中缺失的字段保留原值,因此复用解析变量可能让错误响应通过测试。
因此,每次解析独立响应时应使用新的变量。函数的命名返回变量(例如 func(...) (got Target))也会在每次调用时重新初始化为零值。
例如,已有 Name: "demo"、Addr: "localhost:8080" 的结构体,解析 {"name":"updated"} 后只会更新 Name,Addr 仍保留原值。解析 {} 不会清空这些字段;解析 {"name":""} 才会把 Name 设为空字符串。在当前 encoding/json 中,null 对普通字符串、整数等字段不产生修改,不能用它清零。
测试需要验证接口行为和状态变化
用创建响应返回的 ID 构造路径,后续始终操作同一资源,并检查响应 ID 一致。PUT 后再次 GET,才能确认更新确实写入;DELETE 后检查 204、空响应体,再 GET 检查 404。
测试也需要隔离和清晰的失败信息
独立场景从明确的初始数据开始;使用全局状态时暂不并行运行这些场景。辅助函数加 t.Helper();后续步骤依赖的条件失败时用 t.Fatalf,可以继续检查的字段差异用 t.Errorf。
每个请求都使用新的 Recorder,断言和错误日志必须检查当前请求对应的 Recorder。发送 DELETE 后若误检查上一次 GET 的 Recorder,就会把之前的 200 当作删除响应。
请求经过注册了 GET /target/{id} 的 ServeMux 后,路由器会填入 PathValue("id")。仅构造 /target/1 的请求再直接调用 Handler,不会自动得到这个路径参数;直接测试 Handler 时需要用 req.SetPathValue("id", "1") 显式设置。
一个简单实例
下面是基于当前 sentinel-go Handler 和共享变量的串行 CRUD 测试示例,需要与项目代码同包使用。它验证成功流程,不代表并发请求或所有错误输入均已覆盖。当前创建接口约定返回 200。
package main
import (
"encoding/json"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
)
func CheckCode(rec *httptest.ResponseRecorder, needCode int, t *testing.T) {
t.Helper()
if rec.Code != needCode {
t.Errorf("status = %d,want %d,body = %s",
rec.Code, needCode, rec.Body.String())
}
}
func CheckHeader(rec *httptest.ResponseRecorder, needHeader string, t *testing.T) {
t.Helper()
if got := rec.Header().Get("Content-Type"); got != needHeader {
t.Errorf("Content-Type = %s,want %s", got, needHeader)
}
}
func TestHealthz(t *testing.T) {
router := http.NewServeMux()
router.HandleFunc("/healthz", healthz)
req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
CheckCode(rec, http.StatusOK, t)
CheckHeader(rec, "application/json", t)
var body struct {
Status string `json:"status"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if body.Status != "ok" {
t.Errorf("status field = %q, want ok", body.Status)
}
}
func TestHealthzMethodNotAllowed(t *testing.T) {
router := http.NewServeMux()
router.HandleFunc("/healthz", healthz)
req := httptest.NewRequest(http.MethodPost, "/healthz", nil)
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
CheckCode(rec, http.StatusMethodNotAllowed, t)
}
func TestCreateAndGetTarget(t *testing.T) {
mu.Lock()
targets = make(map[int]Target)
globalId = 0
mu.Unlock()
router := http.NewServeMux()
router.HandleFunc("POST /target", addTarget)
router.HandleFunc("GET /target/{id}", getTarget)
router.HandleFunc("PUT /target/{id}", updateTarget)
router.HandleFunc("DELETE /target/{id}", deleteTarget)
// == create ==
createReq := httptest.NewRequest(
http.MethodPost,
"/target",
strings.NewReader(`{"name":"demo","address":"localhost:8080"}`),
)
createReq.Header.Set("Content-Type", "application/json")
createRec := httptest.NewRecorder()
router.ServeHTTP(createRec, createReq)
CheckCode(createRec, http.StatusOK, t)
CheckHeader(createRec, "application/json", t)
checkTarget := func(rec *httptest.ResponseRecorder) (got Target) {
t.Helper()
if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil {
t.Fatalf("decode response: %v", err)
}
return
}
created := checkTarget(createRec)
if created.Id <= 0 {
t.Fatalf("created id = %d, want positive id", created.Id)
}
if created.Name != "demo" || created.Addr != "localhost:8080" {
t.Errorf("wrong result,body = %s", createRec.Body.String())
}
// == GET : 1 ==
path := "/target/" + strconv.Itoa(created.Id)
getReq := httptest.NewRequest(
http.MethodGet,
path,
nil,
)
getRec := httptest.NewRecorder()
router.ServeHTTP(getRec, getReq)
CheckCode(getRec, http.StatusOK, t)
CheckHeader(getRec, "application/json", t)
geted := checkTarget(getRec)
if geted.Id != created.Id {
t.Fatalf("GET id = %d, want %d", geted.Id, created.Id)
}
if geted.Name != "demo" || geted.Addr != "localhost:8080" {
t.Errorf("wrong result,body = %s", getRec.Body.String())
}
// == PUT ==
putReq := httptest.NewRequest(
http.MethodPut,
path,
strings.NewReader(`{"name":"updated","address":"localhost:9090"}`),
)
putRec := httptest.NewRecorder()
router.ServeHTTP(putRec, putReq)
CheckCode(putRec, http.StatusOK, t)
CheckHeader(putRec, "application/json", t)
putres := checkTarget(putRec)
if putres.Id != created.Id {
t.Fatalf("PUT id = %d, want %d", putres.Id, created.Id)
}
if putres.Name != "updated" || putres.Addr != "localhost:9090" {
t.Errorf("wrong result,body = %s", putRec.Body.String())
}
// == GET : 2 ==
reGetReq := httptest.NewRequest(
http.MethodGet,
path,
nil,
)
reGetRec := httptest.NewRecorder()
router.ServeHTTP(reGetRec, reGetReq)
CheckCode(reGetRec, http.StatusOK, t)
CheckHeader(reGetRec, "application/json", t)
reGet := checkTarget(reGetRec)
if reGet.Id != created.Id {
t.Fatalf("GET id = %d, want %d", reGet.Id, created.Id)
}
if reGet.Name != "updated" || reGet.Addr != "localhost:9090" {
t.Errorf("wrong result,body = %s", reGetRec.Body.String())
}
// == DELETE ==
deleteReq := httptest.NewRequest(
http.MethodDelete,
path,
nil,
)
deleteRec := httptest.NewRecorder()
router.ServeHTTP(deleteRec, deleteReq)
CheckCode(deleteRec, http.StatusNoContent, t)
if deleteRec.Body.Len() != 0 {
t.Errorf("DELETE body = %q, want empty", deleteRec.Body.String())
}
// == GET : 3 ==
rreGetReq := httptest.NewRequest(
http.MethodGet,
path,
nil,
)
rreGetRec := httptest.NewRecorder()
router.ServeHTTP(rreGetRec, rreGetReq)
CheckCode(rreGetRec, http.StatusNotFound, t)
}go