Go / 系统课时

建立端到端验收基线

建立端到端验收基线

端到端验收的目标不是重复单元测试,而是从真实 HTTP 客户端视角确认路由、中间件、认证、超时映射与过载保护能共同工作。本文用 httptest.Server 搭建一个最小可运行基线,一次覆盖正常请求、参数校验失败、下游超时、认证失败和过载拒绝五条关键路径。

学习目标

  • 使用 httptest.Server 通过真实 TCP HTTP 请求验证服务行为
  • 为成功、校验、认证、下游超时和过载路径建立稳定断言
  • 让失败信息只依赖状态码与响应体等外部契约,避免绑定内部实现

先确定验收矩阵

端到端基线应优先覆盖“用户或上游真正能观察到的结果”。下面五条路径形成最小生产验收集:正常请求返回 200;缺少参数返回 400;无凭据返回 401;下游处理超过期限返回 504;并发槽位耗尽返回 503。

场景 请求条件 预期状态
正常请求 有认证且参数有效 200
校验失败 缺少 id 400
认证失败 缺少 Bearer Token 401
下游超时 id=slow 504
过载拒绝 并发槽位已占用 503

用 httptest.Server 跑真实 HTTP 链路

示例服务包含认证中间件、参数校验、一个可控的慢下游和容量为 1 的并发信号量。测试通过 httptest.NewServer 启动真实监听器,再使用 http.Client 发请求,因此会穿过路由和中间件,而不是直接调用 handler 函数。

go
package main

import (
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"
	"time"
)

func newHandler(slowStarted chan<- struct{}) http.Handler {
	sem := make(chan struct{}, 1)
	var signalOnce sync.Once

	app := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Query().Get("id") == "" {
			http.Error(w, "missing id", http.StatusBadRequest)
			return
		}

		select {
		case sem <- struct{}{}:
			defer func() { <-sem }()
		default:
			http.Error(w, "overloaded", http.StatusServiceUnavailable)
			return
		}

		if r.URL.Query().Get("id") == "slow" {
			signalOnce.Do(func() { close(slowStarted) })
			select {
			case <-time.After(100 * time.Millisecond):
			case <-r.Context().Done():
				return
			}
			http.Error(w, "upstream timeout", http.StatusGatewayTimeout)
			return
		}

		w.WriteHeader(http.StatusOK)
		_, _ = w.Write([]byte("ok"))
	})

	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("Authorization") != "Bearer test-token" {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		app.ServeHTTP(w, r)
	})
}

func doRequest(client *http.Client, url string, auth bool) (int, string, error) {
	req, err := http.NewRequest(http.MethodGet, url, nil)
	if err != nil {
		return 0, "", err
	}
	if auth {
		req.Header.Set("Authorization", "Bearer test-token")
	}
	resp, err := client.Do(req)
	if err != nil {
		return 0, "", err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return 0, "", err
	}
	return resp.StatusCode, strings.TrimSpace(string(body)), nil
}

func TestEndToEndBaseline(t *testing.T) {
	slowStarted := make(chan struct{})
	ts := httptest.NewServer(newHandler(slowStarted))
	defer ts.Close()

	client := ts.Client()
	client.Timeout = time.Second

	tests := []struct {
		name       string
		path       string
		auth       bool
		wantStatus int
		wantBody   string
	}{
		{"ok", "/items?id=42", true, http.StatusOK, "ok"},
		{"validation", "/items", true, http.StatusBadRequest, "missing id"},
		{"auth", "/items?id=42", false, http.StatusUnauthorized, "unauthorized"},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			status, body, err := doRequest(client, ts.URL+tc.path, tc.auth)
			if err != nil {
				t.Fatal(err)
			}
			if status != tc.wantStatus || body != tc.wantBody {
				t.Fatalf("got status=%d body=%q, want status=%d body=%q",
					status, body, tc.wantStatus, tc.wantBody)
			}
		})
	}

	slowResult := make(chan error, 1)
	go func() {
		status, body, err := doRequest(client, ts.URL+"/items?id=slow", true)
		if err == nil && (status != http.StatusGatewayTimeout || body != "upstream timeout") {
			err = fmt.Errorf("slow got status=%d body=%q", status, body)
		}
		slowResult <- err
	}()

	<-slowStarted // 明确等待慢请求占用唯一并发槽位
	status, body, err := doRequest(client, ts.URL+"/items?id=42", true)
	if err != nil {
		t.Fatal(err)
	}
	if status != http.StatusServiceUnavailable || body != "overloaded" {
		t.Fatalf("overload got status=%d body=%q", status, body)
	}
	if err := <-slowResult; err != nil {
		t.Fatal(err)
	}
}

预期输出

text
PASS
ok  	<PACKAGE>	<TIME>

<PACKAGE> 与 <TIME> 取决于本地模块名和运行耗时。只要任一路径的状态码或正文偏离契约,测试就会失败并打印实际值与期望值。示例用 slowStarted 显式同步并发状态,避免依赖固定睡眠造成偶发失败。

运行验收并理解边界

把示例保存为 e2e_test.go 后,在对应 Go 模块目录执行测试。httptest.Server 会为每次测试分配临时监听地址,因此无需固定端口,也能避免和本机已有服务冲突。

bash
go test -run TestEndToEndBaseline -v

预期输出

text
=== RUN   TestEndToEndBaseline
=== RUN   TestEndToEndBaseline/ok
=== RUN   TestEndToEndBaseline/validation
=== RUN   TestEndToEndBaseline/auth
--- PASS: TestEndToEndBaseline (<TIME>)
    --- PASS: TestEndToEndBaseline/ok (<TIME>)
    --- PASS: TestEndToEndBaseline/validation (<TIME>)
    --- PASS: TestEndToEndBaseline/auth (<TIME>)
PASS
ok  	<PACKAGE>	<TIME>

下游超时与过载路径在父测试中通过一组协作请求完成,所以不会出现独立的 /timeout 或 /overload 子测试名称,但两者都被状态码和响应体断言覆盖。若 CI 希望逐场景展示名称,可以把这组协作逻辑封装后再放入独立子测试。

保持验收稳定

端到端测试应断言外部契约,而不是内部函数调用次数。对真实下游,可以用可控测试服务器稳定制造超时、错误响应或断连;对于独立进程验收,还应让测试分配监听端口,并在用例结束时确保子进程被回收。

这类基线的价值在于“发布前可重复”:即使将来替换路由器、认证实现或下游客户端,只要 HTTP 状态与响应契约不变,验收仍然有效;一旦关键失败路径发生回归,CI 会在上线前给出明确失败。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

建立端到端验收基线

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通