《互联网产品的服务端架构·交易、增长与平台化》13.2 券与活动的端到端验证

// file: internal/growthbase/e2e.go
// tier: L1
// verify: go test ./internal/growthbase/

package growthbase

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
)

// RequestStep 描述一次端到端请求及其期望状态码。
type RequestStep struct {
	Name       string
	Method     string
	Path       string
	Body       string
	WantStatus int
}

// Scenario 是一组按顺序执行的请求。
type Scenario struct {
	Name  string
	Steps []RequestStep
}

// Result 汇总一次场景执行的结果。Failed 中是失败步骤及其原因。
type Result struct {
	Passed int
	Failed []string
}

// Run 在进程内用 httptest 真跑整个场景。
//
// 单步失败不会中断后续步骤：端到端验证要看到“退款没退券”之后
// 库存是否仍被占用，而不是在第一个断言失败时就停下。handler 的 panic
// 被转换成失败记录，避免一个坏路由拖垮整轮验证。
func Run(sc Scenario, h http.Handler) (Result, error) {
	if h == nil {
		return Result{}, fmt.Errorf("growthbase: scenario %q has nil handler", sc.Name)
	}
	if len(sc.Steps) == 0 {
		return Result{}, fmt.Errorf("growthbase: scenario %q has no steps", sc.Name)
	}
	var res Result
	for _, st := range sc.Steps {
		code, err := runStep(st, h)
		if err != nil {
			res.Failed = append(res.Failed, fmt.Sprintf("%s: %v", st.Name, err))
			continue
		}
		if code != st.WantStatus {
			res.Failed = append(res.Failed, fmt.Sprintf("%s: status %d, want %d", st.Name, code, st.WantStatus))
			continue
		}
		res.Passed++
	}
	return res, nil
}

func runStep(st RequestStep, h http.Handler) (code int, err error) {
	if strings.TrimSpace(st.Method) == "" {
		return 0, fmt.Errorf("empty method")
	}
	if strings.TrimSpace(st.Path) == "" {
		return 0, fmt.Errorf("empty path")
	}
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("handler panic: %v", r)
		}
	}()
	req := httptest.NewRequest(st.Method, st.Path, strings.NewReader(st.Body))
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, req)
	return rec.Code, nil
}

// file: internal/growthbase/e2e_test.go
// tier: L1
// verify: go test ./internal/growthbase/

package growthbase

import (
	"net/http"
	"strings"
	"testing"
)

func tradeHandler() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /cart", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})
	mux.HandleFunc("POST /orders", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusCreated)
	})
	mux.HandleFunc("POST /orders/o-1/pay", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	})
	mux.HandleFunc("POST /orders/o-1/refund", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusConflict)
	})
	return mux
}

func TestRunContinuesAfterFailure(t *testing.T) {
	sc := Scenario{Name: "trade-e2e", Steps: []RequestStep{
		{Name: "view-cart", Method: "GET", Path: "/cart", WantStatus: http.StatusOK},
		{Name: "create-order", Method: "POST", Path: "/orders", Body: `{"sku":"a"}`, WantStatus: http.StatusCreated},
		{Name: "pay-order", Method: "POST", Path: "/orders/o-1/pay", WantStatus: http.StatusOK},
		{Name: "refund", Method: "POST", Path: "/orders/o-1/refund", WantStatus: http.StatusOK},
	}}
	res, err := Run(sc, tradeHandler())
	if err != nil {
		t.Fatalf("run: %v", err)
	}
	if res.Passed != 3 {
		t.Fatalf("passed = %d, want 3", res.Passed)
	}
	if len(res.Failed) != 1 {
		t.Fatalf("failed = %v, want one entry", res.Failed)
	}
	if !strings.Contains(res.Failed[0], "status 409, want 200") {
		t.Fatalf("unexpected failure %q", res.Failed[0])
	}
}

func TestRunRejectsEmptyScenario(t *testing.T) {
	if _, err := Run(Scenario{Name: "empty"}, tradeHandler()); err == nil {
		t.Fatal("want error for empty scenario")
	}
}

func TestRunRejectsNilHandler(t *testing.T) {
	if _, err := Run(Scenario{Name: "nil", Steps: []RequestStep{{Name: "x", Method: "GET", Path: "/"}}}, nil); err == nil {
		t.Fatal("want error for nil handler")
	}
}

func TestRunRecoversHandlerPanic(t *testing.T) {
	h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		panic("boom")
	})
	res, err := Run(Scenario{Name: "panic", Steps: []RequestStep{
		{Name: "boom", Method: "GET", Path: "/boom", WantStatus: http.StatusOK},
	}}, h)
	if err != nil {
		t.Fatalf("run returned error: %v", err)
	}
	if res.Passed != 0 || len(res.Failed) != 1 {
		t.Fatalf("passed = %d, failed = %v", res.Passed, res.Failed)
	}
	if !strings.Contains(res.Failed[0], "handler panic") {
		t.Fatalf("unexpected failure %q", res.Failed[0])
	}
}

func TestRunRejectsEmptyMethodAndPath(t *testing.T) {
	res, err := Run(Scenario{Name: "bad", Steps: []RequestStep{
		{Name: "no-method", Method: " ", Path: "/cart", WantStatus: http.StatusOK},
		{Name: "no-path", Method: "GET", Path: " ", WantStatus: http.StatusOK},
	}}, tradeHandler())
	if err != nil {
		t.Fatalf("run: %v", err)
	}
	if res.Passed != 0 || len(res.Failed) != 2 {
		t.Fatalf("passed = %d, failed = %v", res.Passed, res.Failed)
	}
}

cd .local/checks/webapp-lab && go test ./internal/growthbase/ -run 'TestRun' -count=1 -v

=== RUN   TestRunContinuesAfterFailure
--- PASS: TestRunContinuesAfterFailure (0.00s)
=== RUN   TestRunRejectsEmptyScenario
--- PASS: TestRunRejectsEmptyScenario (0.00s)
=== RUN   TestRunRejectsNilHandler
--- PASS: TestRunRejectsNilHandler (0.00s)
=== RUN   TestRunRecoversHandlerPanic
--- PASS: TestRunRecoversHandlerPanic (0.00s)
=== RUN   TestRunRejectsEmptyMethodAndPath
--- PASS: TestRunRejectsEmptyMethodAndPath (0.00s)
PASS
ok  	webapp/internal/growthbase	0.367s