imicola HttpTest
HttpTest

HttpTest

852 字 · 约 2 分钟

回忆我们编写的Handler

func healthz(w http.ResponseWriter,r *http.Request)
go

Handler 通过 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.Request
go

第一个参数是 HTTP 方法,第二个参数是请求目标(如 /target),第三个参数是请求体。请求体需要是实现了 io.Reader 接口的值;没有请求体时可以传 nil。例如:

strings.NewReader(`{"name":"demo"}`)         // 输入为 string
bytes.NewReader([]byte(`{"name":"demo"}`))  // 输入为 []byte
go

这两个函数返回的值都实现了 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