Day 060 — 2026-09-29 | ミドルウェア設計パターン: 4 本のミドルウェアが「単体では正しい」のに、積むと壊れる——gzip の defer が panic を 200 にし、Flush が溜めに止まる 6 つのバグをテストで直す

📋 コピーpackage main

import (
	"compress/gzip"
	"log/slog"
	"net/http"
	"strings"
	"time"
)

type Middleware func(http.Handler) http.Handler

// Chain は先に書いたものが外側になるように積む。
func Chain(h http.Handler, mws ...Middleware) http.Handler {
	for i := len(mws) - 1; i >= 0; i-- {
		h = mws[i](h)
	}
	return h
}

// ---- 状態コードを覚える ResponseWriter ----

type statusRecorder struct {
	http.ResponseWriter
	status int
}

func (s *statusRecorder) WriteHeader(code int) {
	s.status = code
	s.ResponseWriter.WriteHeader(code)
}

func (s *statusRecorder) Write(b []byte) (int, error) {
	if s.status == 0 {
		s.status = http.StatusOK
	}
	return s.ResponseWriter.Write(b)
}

func (s *statusRecorder) Unwrap() http.ResponseWriter { return s.ResponseWriter }

// ---- アクセスログ ----

func AccessLog(l *slog.Logger) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			rec := &statusRecorder{ResponseWriter: w}
			start := time.Now()
			defer l.Info("request", "method", r.Method, "path", r.URL.Path,
				"status", rec.status, "dur_ms", time.Since(start).Milliseconds())
			next.ServeHTTP(rec, r)
		})
	}
}

// ---- panic を 500 にする ----

func Recover(l *slog.Logger) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			defer func() {
				if v := recover(); v != nil {
					l.Error("panic", "value", v, "path", r.URL.Path)
					http.Error(w, "internal server error", http.StatusInternalServerError)
				}
			}()
			next.ServeHTTP(w, r)
		})
	}
}

// ---- gzip ----

type gzipWriter struct {
	http.ResponseWriter
	gz *gzip.Writer
}

func (g *gzipWriter) Write(b []byte) (int, error) { return g.gz.Write(b) }

func Gzip(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Add("Vary", "Accept-Encoding")
		if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
			next.ServeHTTP(w, r)
			return
		}
		w.Header().Set("Content-Encoding", "gzip")
		gz := gzip.NewWriter(w)
		defer gz.Close()
		next.ServeHTTP(&gzipWriter{ResponseWriter: w, gz: gz}, r)
	})
}

📋 コピーpackage main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"
	"time"
)

type syncBuf struct {
	mu sync.Mutex
	b  bytes.Buffer
}

func (s *syncBuf) Write(p []byte) (int, error) { s.mu.Lock(); defer s.mu.Unlock(); return s.b.Write(p) }
func (s *syncBuf) String() string              { s.mu.Lock(); defer s.mu.Unlock(); return s.b.String() }

func setup(t *testing.T) (*httptest.Server, *syncBuf, chan struct{}) {
	t.Helper()
	buf := &syncBuf{}
	release := make(chan struct{})
	srv := httptest.NewServer(newHandler(slog.New(slog.NewJSONHandler(buf, nil)), release))
	t.Cleanup(srv.Close)
	return srv, buf, release
}

// logStatus は msg=="request" の行のうち path が一致するものの status を返す。
func logStatus(t *testing.T, buf *syncBuf, path string) int {
	t.Helper()
	deadline := time.Now().Add(2 * time.Second) // ログはレスポンス送出後に書かれるので少し待つ
	for time.Now().Before(deadline) {
		for _, line := range strings.Split(buf.String(), "\n") {
			var m map[string]any
			if json.Unmarshal([]byte(line), &m) == nil && m["msg"] == "request" && m["path"] == path {
				return int(m["status"].(float64))
			}
		}
		time.Sleep(10 * time.Millisecond)
	}
	t.Fatalf("path=%s のアクセスログが出ていない:\n%s", path, buf.String())
	return 0
}

// B1: defer の引数は defer を書いた時点で評価される
func TestAccessLogRecordsStatus(t *testing.T) {
	srv, buf, _ := setup(t)
	resp, err := http.Get(srv.URL + "/created")
	if err != nil {
		t.Fatal(err)
	}
	io.Copy(io.Discard, resp.Body)
	resp.Body.Close()
	if got := logStatus(t, buf, "/created"); got != 201 {
		t.Fatalf("ログの status = %d, want 201", got)
	}
}

// B2: 本文を書いた後の http.Error は無視される。ログも最初の状態コードのまま
func TestFirstWriteHeaderWins(t *testing.T) {
	srv, buf, _ := setup(t)
	resp, err := http.Get(srv.URL + "/late")
	if err != nil {
		t.Fatal(err)
	}
	io.Copy(io.Discard, resp.Body)
	resp.Body.Close()
	if resp.StatusCode != 200 {
		t.Fatalf("クライアントが見た status = %d, want 200", resp.StatusCode)
	}
	if got := logStatus(t, buf, "/late"); got != 200 {
		t.Fatalf("ログの status = %d, want 200（クライアントが見た値と一致させる）", got)
	}
}

// B3: ErrAbortHandler は「接続を切れ」という合図。500 に変えてはいけない
func TestAbortHandlerIsNotRecovered(t *testing.T) {
	srv, _, _ := setup(t)
	resp, err := http.Get(srv.URL + "/abort")
	if err == nil {
		resp.Body.Close()
		t.Fatalf("接続が切れるはずが status=%d で応答した", resp.StatusCode)
	}
}

// 守る側: 普通の panic は今までどおり 500
func TestPanicStillBecomes500(t *testing.T) {
	srv, _, _ := setup(t)
	resp, err := http.Get(srv.URL + "/boom")
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	if resp.StatusCode != 500 {
		t.Fatalf("status = %d, want 500", resp.StatusCode)
	}
}

// B4: 自分で付けた Content-Length は gzip 後の長さと合わない
func TestGzipWithContentLength(t *testing.T) {
	srv, _, _ := setup(t)
	resp, err := http.Get(srv.URL + "/big") // Go の Transport は Accept-Encoding: gzip を自動で付けて自動で伸長する
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Fatalf("本文の読み取りに失敗: %v", err)
	}
	if len(body) != 2000 {
		t.Fatalf("len(body) = %d, want 2000", len(body))
	}
}

// 守る側: gzip を受け付けないクライアントには、そのまま・Content-Length 付きで返す
func TestPlainClientKeepsContentLength(t *testing.T) {
	srv, _, _ := setup(t)
	c := &http.Client{Transport: &http.Transport{DisableCompression: true}}
	resp, err := c.Get(srv.URL + "/big")
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	if len(body) != 2000 || resp.Header.Get("Content-Encoding") != "" || resp.ContentLength != 2000 {
		t.Fatalf("len=%d enc=%q CL=%d", len(body), resp.Header.Get("Content-Encoding"), resp.ContentLength)
	}
	if !strings.Contains(resp.Header.Get("Vary"), "Accept-Encoding") {
		t.Fatalf("Vary に Accept-Encoding が無い: %q", resp.Header.Get("Vary"))
	}
}

// B5: gzip の内側の Flush は、gzip のバッファも吐き出して初めてクライアントに届く
func TestGzipFlushReachesClient(t *testing.T) {
	srv, _, release := setup(t)
	defer close(release) // 失敗しても /events のハンドラを解放して srv.Close が詰まらないようにする

	type result struct {
		line string
		err  error
	}
	got := make(chan result, 1)
	go func() {
		resp, err := http.Get(srv.URL + "/events") // ヘッダ自体が Flush されないとここで止まる
		if err != nil {
			got <- result{err: err}
			return
		}
		defer resp.Body.Close()
		line, err := bufio.NewReader(resp.Body).ReadString('\n')
		got <- result{line, err}
	}()
	select {
	case r := <-got:
		if r.err != nil || r.line != "data: 1\n" {
			t.Fatalf("1 件目 = %q, err = %v", r.line, r.err)
		}
	case <-time.After(2 * time.Second):
		t.Fatal("Flush したのに 2 秒たっても 1 件目が届かない")
	}
}