Day 069 — 2026-10-09 | ミドルウェア設計パターン: error を返すハンドラ（Echo・Caddy 型）を net/http に橋渡しする Adapt——error→ステータスの表、送信後の error、外側の中間件との順序を 13 本のテストと 14 通りの変異で決める

📋 コピーpackage main

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

// logRec は LogFunc の呼び出しを全部覚える。
type logRec struct {
	mu   sync.Mutex
	recs []string
}

func (l *logRec) fn(r *http.Request, status int, err error) {
	l.mu.Lock()
	defer l.mu.Unlock()
	l.recs = append(l.recs, fmt.Sprintf("%d %v", status, err))
}
func (l *logRec) all() []string {
	l.mu.Lock()
	defer l.mu.Unlock()
	return append([]string(nil), l.recs...)
}

// do は Adapt を httptest.Recorder で 1 回呼ぶ。
func do(t *testing.T, h HandlerE, r *http.Request) (*httptest.ResponseRecorder, []string) {
	t.Helper()
	l := &logRec{}
	if r == nil {
		r = httptest.NewRequest("GET", "/x", nil)
	}
	rec := httptest.NewRecorder()
	Adapt(h, l.fn).ServeHTTP(rec, r)
	return rec, l.all()
}

func want(t *testing.T, rec *httptest.ResponseRecorder, logs []string, code int, body string, nlog int) {
	t.Helper()
	if rec.Code != code || rec.Body.String() != body || len(logs) != nlog {
		t.Fatalf("got %d %q logs=%q; want %d %q logs=%d", rec.Code, rec.Body.String(), logs, code, body, nlog)
	}
}

// A1: error が nil なら、ハンドラが書いたものに一切触らない。ログも出さない。
func TestA1_NilPassesThrough(t *testing.T) {
	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		w.WriteHeader(201)
		io.WriteString(w, "ok")
		return nil
	}, nil)
	want(t, rec, logs, 201, "ok", 0)
}

// A2: 包まれた *StatusError からステータスと公開文言を取り出す。原因はログにだけ出る。
func TestA2_StatusErrorWrapped(t *testing.T) {
	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("handler: %w", &StatusError{Code: 400, Msg: "bad id", Err: errors.New("strconv: \"x\"")})
	}, nil)
	want(t, rec, logs, 400, "bad id\n", 1)
	if !strings.Contains(logs[0], "strconv") {
		t.Fatalf("原因がログに無い: %q", logs)
	}
}

// A3: 番兵 ErrNotFound（包まれていても）は 404。ただし *StatusError が先に当たる。
func TestA3_SentinelAndPrecedence(t *testing.T) {
	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("repo.Get(42): %w", ErrNotFound)
	}, nil)
	want(t, rec, logs, 404, "Not Found\n", 1)

	rec, logs = do(t, func(w http.ResponseWriter, r *http.Request) error {
		return &StatusError{Code: 410, Err: ErrNotFound}
	}, nil)
	want(t, rec, logs, 410, "Gone\n", 1)
}

// A4: 失敗として使えないコード（0・200・1000）は 500。WriteHeader(0) の panic にしない。
func TestA4_InvalidCodes(t *testing.T) {
	for _, c := range []int{0, 200, 302, 1000} {
		rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
			return &StatusError{Code: c, Msg: "x"}
		}, nil)
		if rec.Code != 500 || len(logs) != 1 {
			t.Fatalf("Code=%d: got %d logs=%q; want 500", c, rec.Code, logs)
		}
	}
}

// A5: 想定外の error は 500。本文に error の中身を出さない（CWE-209）。ログには出す。
func TestA5_NoLeak(t *testing.T) {
	secret := "pq: password authentication failed for user \"app\" host=10.0.3.7"
	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		return errors.New(secret)
	}, nil)
	want(t, rec, logs, 500, "internal error\n", 1)
	if !strings.Contains(logs[0], "10.0.3.7") {
		t.Fatalf("ログに原因が無い: %q", logs)
	}
	// 5xx の StatusError も、Msg が内部情報なら出さない
	rec, logs = do(t, func(w http.ResponseWriter, r *http.Request) error {
		return &StatusError{Code: 502, Msg: "upstream 10.0.3.7:5432 refused"}
	}, nil)
	want(t, rec, logs, 502, "internal error\n", 1)
}

// A6: 期限切れは 503（http.TimeoutHandler と同じ番号）。
func TestA6_Deadline(t *testing.T) {
	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("db: %w", context.DeadlineExceeded)
	}, nil)
	want(t, rec, logs, 503, "internal error\n", 1)
}

// countWriter は WriteHeader と Write が呼ばれたかを数える（Recorder は「呼ばれなかった」を区別できない）。
type countWriter struct {
	h            http.Header
	headers, wrs int
}

func (c *countWriter) Header() http.Header         { return c.h }
func (c *countWriter) WriteHeader(int)             { c.headers++ }
func (c *countWriter) Write(b []byte) (int, error) { c.wrs++; return len(b), nil }

// A7: context.Canceled は「誰が切ったか」で分ける。
// 相手が切った（r.Context() が終わっている）→ 何も書かず、ログに 499。
// 中で誰かが cancel しただけ（r.Context() は生きている）→ 500。
func TestA7_CanceledWhoCut(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	r := httptest.NewRequest("GET", "/x", nil).WithContext(ctx)
	cw := &countWriter{h: http.Header{}}
	l := &logRec{}
	Adapt(func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("query: %w", r.Context().Err())
	}, l.fn).ServeHTTP(cw, r)
	if cw.headers != 0 || cw.wrs != 0 || len(l.all()) != 1 || !strings.HasPrefix(l.all()[0], "499 ") {
		t.Fatalf("相手が切った: headers=%d writes=%d logs=%q; want 0 0 [499 ...]", cw.headers, cw.wrs, l.all())
	}

	rec, logs := do(t, func(w http.ResponseWriter, r *http.Request) error {
		inner, stop := context.WithCancel(r.Context())
		stop() // 中で打ち切った（例: errgroup の兄弟が失敗）
		return fmt.Errorf("fan-out: %w", inner.Err())
	}, nil)
	want(t, rec, logs, 500, "internal error\n", 1)
}

// serve は実サーバーに 1 回投げ、ステータスと本文と読み取りエラーを返す。
func serve(t *testing.T, h http.Handler) (int, string, error) {
	t.Helper()
	srv := httptest.NewServer(h)
	defer srv.Close()
	res, err := http.Get(srv.URL)
	if err != nil {
		return 0, "", err
	}
	defer res.Body.Close()
	b, err := io.ReadAll(res.Body)
	return res.StatusCode, string(b), err
}

// A8: 200 で本文を書き始めた後の error。クライアントに「完全な 200」を渡さない（接続を切る）。
// WriteHeader を呼ばずに Write だけした場合も同じ（暗黙の 200）。
func TestA8_ErrorAfterSuccessCommit(t *testing.T) {
	for _, explicit := range []bool{true, false} {
		l := &logRec{}
		h := Adapt(func(w http.ResponseWriter, r *http.Request) error {
			if explicit {
				w.WriteHeader(200)
			}
			io.WriteString(w, "row1\n")
			http.NewResponseController(w).Flush() // ここで送信済み（chunked）
			return errors.New("row2: scan failed")
		}, l.fn)
		code, body, err := serve(t, h)
		t.Logf("A8 explicit=%v: status=%d body=%q readErr=%v logs=%q", explicit, code, body, err, l.all())
		if !errors.Is(err, io.ErrUnexpectedEOF) {
			t.Fatalf("explicit=%v: 読み取りが %v。途中の本文が完全な応答として届いた", explicit, err)
		}
		if logs := l.all(); len(logs) != 1 || !strings.HasPrefix(logs[0], "200 ") {
			t.Fatalf("logs=%q; want [200 ...] 1 件", logs)
		}
	}
}

// A9: Echo の RequestLogger(HandleError: true) のように、中の中間件が失敗の応答を書いてから
// error を返す。Adapt は 2 度書かず、接続も切らず、ログは 1 回。
func TestA9_AlreadyHandledByMiddleware(t *testing.T) {
	handled := func(next HandlerE) HandlerE {
		return func(w http.ResponseWriter, r *http.Request) error {
			err := next(w, r)
			if err != nil {
				s := StatusOf(r, err)
				http.Error(w, publicMsg(err, s), s) // 先に書く
			}
			return err // それでも上へ返す（Echo と同じ）
		}
	}
	l := &logRec{}
	h := Adapt(ChainE(func(w http.ResponseWriter, r *http.Request) error {
		return fmt.Errorf("get: %w", ErrNotFound)
	}, handled), l.fn)
	code, body, err := serve(t, h)
	if err != nil || code != 404 || body != "Not Found\n" || len(l.all()) != 1 {
		t.Fatalf("got %d %q err=%v logs=%q; want 404 \"Not Found\\n\" nil 1 件", code, body, err, l.all())
	}
}

// Observe は Day063 と同じ A 型の集計中間件（ステータスだけ覚える）。
type obsWriter struct {
	http.ResponseWriter
	status int
}

func (o *obsWriter) WriteHeader(c int) { o.status = c; o.ResponseWriter.WriteHeader(c) }
func (o *obsWriter) Write(b []byte) (int, error) {
	if o.status == 0 {
		o.status = 200
	}
	return o.ResponseWriter.Write(b)
}
func (o *obsWriter) Unwrap() http.ResponseWriter { return o.ResponseWriter }

func Observe(got *int) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			ow := &obsWriter{ResponseWriter: w}
			next.ServeHTTP(ow, r)
			*got = ow.status
		})
	}
}

// A10: 外側の A 型中間件（集計）は、Adapt が error から決めたステータスを見る。
func TestA10_OuterObserveSeesMappedStatus(t *testing.T) {
	cases := []struct {
		err  error
		want int
	}{
		{nil, 204},
		{ErrNotFound, 404},
		{&StatusError{Code: 429, Msg: "slow down"}, 429},
		{context.DeadlineExceeded, 503},
		{errors.New("boom"), 500},
	}
	for _, c := range cases {
		var got int
		h := Observe(&got)(Adapt(func(w http.ResponseWriter, r *http.Request) error {
			if c.err == nil {
				w.WriteHeader(204)
			}
			return c.err
		}, func(*http.Request, int, error) {}))
		h.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest("GET", "/x", nil))
		if got != c.want {
			t.Fatalf("err=%v: Observe が見たのは %d; want %d", c.err, got, c.want)
		}
	}
}

// A11: Adapt が w を包んでも、http.ResponseController で Flush できる（SSE・大きな応答）。
func TestA11_FlushThroughWrapper(t *testing.T) {
	var ferr error
	rec, _ := do(t, func(w http.ResponseWriter, r *http.Request) error {
		io.WriteString(w, "data: 1\n\n")
		ferr = http.NewResponseController(w).Flush()
		return nil
	}, nil)
	if ferr != nil || !rec.Flushed {
		t.Fatalf("Flush err=%v flushed=%v; want nil true", ferr, rec.Flushed)
	}
}

// A12: 同じ http.Handler を 200 本同時に呼ぶ。リクエストごとの状態が混ざらない（-race で）。
func TestA12_Concurrent(t *testing.T) {
	errs := []error{nil, ErrNotFound, &StatusError{Code: 409, Msg: "conflict"}, errors.New("x")}
	codes := []int{200, 404, 409, 500}
	h := Adapt(func(w http.ResponseWriter, r *http.Request) error {
		i := int(r.URL.Query().Get("i")[0] - '0')
		if errs[i] == nil {
			io.WriteString(w, "ok")
		}
		return errs[i]
	}, func(*http.Request, int, error) {})
	var wg sync.WaitGroup
	bad := make(chan string, 200)
	for n := 0; n < 200; n++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			i := n % 4
			rec := httptest.NewRecorder()
			h.ServeHTTP(rec, httptest.NewRequest("GET", fmt.Sprintf("/x?i=%d", i), nil))
			if rec.Code != codes[i] {
				bad <- fmt.Sprintf("i=%d got %d", i, rec.Code)
			}
		}(n)
	}
	wg.Wait()
	close(bad)
	if n := len(bad); n > 0 {
		t.Fatalf("%d 本が違うステータス（例: %s）", n, <-bad)
	}
}

func BenchmarkPlain(b *testing.B) {
	h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "ok") })
	r := httptest.NewRequest("GET", "/x", nil)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h.ServeHTTP(httptest.NewRecorder(), r)
	}
}

func BenchmarkAdaptNil(b *testing.B) {
	h := Adapt(func(w http.ResponseWriter, r *http.Request) error { io.WriteString(w, "ok"); return nil },
		func(*http.Request, int, error) {})
	r := httptest.NewRequest("GET", "/x", nil)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h.ServeHTTP(httptest.NewRecorder(), r)
	}
}

func BenchmarkAdaptNotFound(b *testing.B) {
	h := Adapt(func(w http.ResponseWriter, r *http.Request) error { return ErrNotFound },
		func(*http.Request, int, error) {})
	r := httptest.NewRequest("GET", "/x", nil)
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		h.ServeHTTP(httptest.NewRecorder(), r)
	}
}

// A13: 103 Early Hints（1xx）は「送信済み」ではない。その後の error は普通に 404 になる。
func TestA13_InformationalIsNotCommit(t *testing.T) {
	l := &logRec{}
	h := Adapt(func(w http.ResponseWriter, r *http.Request) error {
		w.Header().Set("Link", "</app.css>; rel=preload; as=style")
		w.WriteHeader(http.StatusEarlyHints)
		return fmt.Errorf("get: %w", ErrNotFound)
	}, l.fn)
	code, body, err := serve(t, h)
	if err != nil || code != 404 || body != "Not Found\n" || len(l.all()) != 1 {
		t.Fatalf("got %d %q err=%v logs=%q; want 404 \"Not Found\\n\"", code, body, err, l.all())
	}
}

Adapt の仕事は 3 つの場合分けだけです。「error が無い」「error があるが、まだ何も送っていない」「error があり、もう送り始めた」。3 つ目を判定するには、ハンドラに渡す w を自分で包んで、WriteHeader と Write を見張るしかありません。

• StatusOf は switch { case errors.As(…): case errors.Is(…): … } で上から順に。順番そのものが仕様です（A3 は &StatusError{Code: 410, Err: ErrNotFound} を 410 にしたい）
• 「相手が切った」は、error の中身ではなく r.Context().Err() で見ます
• 送信後に接続を切るには panic(http.ErrAbortHandler)。net/http が回収し、スタックも出しません
• 包んだ w には Unwrap() http.ResponseWriter を付けます（http.ResponseController がこれをたどる）

📋 コピーtype commitWriter struct {
	http.ResponseWriter
	status int // 0 = まだ送っていない
}
// WriteHeader: 1xx（101 を除く）なら status を変えない
// Write: status が 0 なら 200 にする
// Unwrap: 中の ResponseWriter を返す

func Adapt(h HandlerE, log LogFunc) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		cw := &commitWriter{ResponseWriter: w} // リクエストごとに作る
		err := h(cw, r)
		// nil → return
		// cw.status != 0 → log(1 回) → 2xx/3xx なら panic(http.ErrAbortHandler)、4xx/5xx なら return
		// それ以外 → status := StatusOf(r, err) → log(1 回) → 499 なら return → http.Error(cw, publicMsg(...), status)
	})
}