/middleware/logger_internal_test.go

package middleware

import (
	"bytes"
	"io"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"github.com/gin-gonic/gin"
)

// newCtxWithBody 构造一个带请求体的 gin.Context，仅用于 logger 内部测试。
func newCtxWithBody(body []byte) *gin.Context {
	req := httptest.NewRequest("POST", "/", bytes.NewReader(body))
	c := &gin.Context{}
	c.Request = req
	return c
}

// TestReadBodyBounded_TruncatesLogCopy 复现 H3：日志副本必须封顶到 maxLen，
// 而不是把整个 body 读入内存后再截断（原 io.ReadAll 无上限 → OOM）。
func TestReadBodyBounded_TruncatesLogCopy(t *testing.T) {
	cases := []struct {
		name    string
		bodyLen int
		maxLen  int
	}{
		{"smaller_than_limit", 100, 1024},
		{"equal_to_limit", 1024, 1024},
		{"larger_than_limit", 100_000, 1024},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			body := bytes.Repeat([]byte("a"), tc.bodyLen)
			c := newCtxWithBody(body)

			got := readBodyBounded(c, tc.maxLen)

			want := tc.bodyLen
			if want > tc.maxLen {
				want = tc.maxLen
			}
			if len(got) != want {
				t.Fatalf("log copy len = %d, want %d (maxLen=%d, bodyLen=%d)", len(got), want, tc.maxLen, tc.bodyLen)
			}
		})
	}
}

// TestReadBodyBounded_RestoresFullBody 是 H3 修复的闭环断言：
// 即使日志副本被截断，下游处理器仍必须能读到完整请求体（io.MultiReader 复原）。
func TestReadBodyBounded_RestoresFullBody(t *testing.T) {
	const maxLen = 64
	body := []byte(strings.Repeat("ABCDEFGH", 1000)) // 8000 字节，远超 maxLen
	c := newCtxWithBody(body)

	logCopy := readBodyBounded(c, maxLen)

	// 日志副本封顶
	if len(logCopy) != maxLen {
		t.Fatalf("log copy len = %d, want %d", len(logCopy), maxLen)
	}

	// 下游必须拿到完整原始 body
	restored, err := io.ReadAll(c.Request.Body)
	if err != nil {
		t.Fatalf("read restored body: %v", err)
	}
	if !bytes.Equal(restored, body) {
		t.Fatalf("downstream body corrupted: got len=%d, want len=%d", len(restored), len(body))
	}
}

// TestReadBodyBounded_PreservesSmallBodyExactly 小于上限时日志副本与原始一致。
func TestReadBodyBounded_PreservesSmallBodyExactly(t *testing.T) {
	body := []byte(`{"user":"alice","password":"secret"}`)
	c := newCtxWithBody(body)

	got := readBodyBounded(c, 1024)
	if !bytes.Equal(got, body) {
		t.Fatalf("log copy = %q, want %q", got, body)
	}

	restored, _ := io.ReadAll(c.Request.Body)
	if !bytes.Equal(restored, body) {
		t.Fatalf("downstream body = %q, want %q", restored, body)
	}
}

// TestBodyLogWriter_Bounded 复现 H3 响应侧：响应体捕获缓冲区必须封顶，
// 完整响应仍写入下游 ResponseWriter。
func TestBodyLogWriter_Bounded(t *testing.T) {
	gin.SetMode(gin.TestMode)
	const maxLen = 32

	rec := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(rec)
	w := &bodyLogWriter{
		ResponseWriter: c.Writer,
		body:           new(bytes.Buffer),
		maxLen:         maxLen,
	}

	large := bytes.Repeat([]byte("Z"), 10_000)
	n, err := w.Write(large)
	if err != nil {
		t.Fatalf("write: %v", err)
	}
	if n != len(large) {
		t.Fatalf("Write returned %d, want %d (下游必须收到完整响应)", n, len(large))
	}
	if w.body.Len() > maxLen {
		t.Fatalf("captured buffer len = %d, must be <= %d (OOM 防护失效)", w.body.Len(), maxLen)
	}
	if w.body.Len() != maxLen {
		t.Fatalf("captured buffer len = %d, want exactly %d", w.body.Len(), maxLen)
	}
	// 下游 ResponseWriter 收到完整内容
	if rec.Body.Len() != len(large) {
		t.Fatalf("downstream response len = %d, want %d", rec.Body.Len(), len(large))
	}
}

// TestBodyLogWriter_NoLimit maxLen<=0 时不限制（向后兼容）。
func TestBodyLogWriter_NoLimit(t *testing.T) {
	gin.SetMode(gin.TestMode)
	rec := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(rec)
	w := &bodyLogWriter{
		ResponseWriter: c.Writer,
		body:           new(bytes.Buffer),
		maxLen:         0,
	}
	data := []byte("hello world")
	if _, err := w.Write(data); err != nil {
		t.Fatalf("write: %v", err)
	}
	if !bytes.Equal(w.body.Bytes(), data) {
		t.Fatalf("captured = %q, want %q", w.body.Bytes(), data)
	}
}

// TestBodyLogWriter_MultiWriteAccumulation 多次小写累积不超过 maxLen，
// 下游仍收到完整拼接结果。
func TestBodyLogWriter_MultiWriteAccumulation(t *testing.T) {
	gin.SetMode(gin.TestMode)
	const maxLen = 32
	rec := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(rec)
	w := &bodyLogWriter{
		ResponseWriter: c.Writer,
		body:           new(bytes.Buffer),
		maxLen:         maxLen,
	}
	chunks := [][]byte{[]byte("0123456789"), []byte("abcdefghij"), []byte("ABCDEFGHIJ"), []byte("zzzzzzzzzz")}
	var downstream bytes.Buffer
	for _, ch := range chunks {
		n, err := w.Write(ch)
		if err != nil || n != len(ch) {
			t.Fatalf("Write chunk %q: n=%d err=%v", ch, n, err)
		}
		downstream.Write(ch)
	}
	if w.body.Len() > maxLen {
		t.Fatalf("captured len = %d, must be <= %d", w.body.Len(), maxLen)
	}
	if w.body.Len() != maxLen {
		t.Fatalf("captured len = %d, want exactly %d", w.body.Len(), maxLen)
	}
	if !bytes.Equal(rec.Body.Bytes(), downstream.Bytes()) {
		t.Fatalf("downstream = %q, want %q", rec.Body.Bytes(), downstream.Bytes())
	}
}

// TestBodyLogWriter_WriteStringBounded WriteString 路径同样封顶。
func TestBodyLogWriter_WriteStringBounded(t *testing.T) {
	gin.SetMode(gin.TestMode)
	const maxLen = 16
	rec := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(rec)
	w := &bodyLogWriter{
		ResponseWriter: c.Writer,
		body:           new(bytes.Buffer),
		maxLen:         maxLen,
	}
	large := strings.Repeat("S", 500)
	n, err := w.WriteString(large)
	if err != nil {
		t.Fatalf("WriteString: %v", err)
	}
	if n != len(large) {
		t.Fatalf("WriteString returned %d, want %d", n, len(large))
	}
	if w.body.Len() > maxLen {
		t.Fatalf("captured len = %d, must be <= %d", w.body.Len(), maxLen)
	}
	if rec.Body.Len() != len(large) {
		t.Fatalf("downstream len = %d, want %d", rec.Body.Len(), len(large))
	}
}

// TestFilterSensitiveQuery P1 #14：query 中的敏感参数值必须脱敏，非敏感原样保留。
func TestFilterSensitiveQuery(t *testing.T) {
	cases := []struct {
		name     string
		in       string
		contains string // 期望结果包含
		absent   string // 期望结果不含（敏感原值）
	}{
		{"empty", "", "", ""},
		{"no sensitive", "page=1&size=20", "page=1", ""},
		{"access_token redacted", "access_token=supersecret123&page=1", "FILTERED", "supersecret123"},
		{"password redacted", "user=alice&password=hunter2", "FILTERED", "hunter2"},
		{"case insensitive key", "Token=abc.def.ghi", "FILTERED", "abc.def.ghi"},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got := filterSensitiveQuery(tc.in)
			if tc.contains != "" && !strings.Contains(got, tc.contains) {
				t.Errorf("filterSensitiveQuery(%q) = %q, want contains %q", tc.in, got, tc.contains)
			}
			if tc.absent != "" && strings.Contains(got, tc.absent) {
				t.Errorf("filterSensitiveQuery(%q) = %q, must NOT contain sensitive value %q", tc.in, got, tc.absent)
			}
		})
	}
}

// TestLoggerWithConfig_NormalizesMaxBodyLength MaxBodyLength<=0 时归一化为默认值，
// 确保响应侧捕获缓冲区仍有上限（H3 复审 MEDIUM：消除请求/响应侧 maxLen<=0 不对称）。
func TestLoggerWithConfig_NormalizesMaxBodyLength(t *testing.T) {
	gin.SetMode(gin.TestMode)
	r := gin.New()
	cfg := LoggerConfig{
		LogRequestBody:       true,
		LogResponseBody:      true,
		MaxBodyLength:        0, // 手滑置 0，应被归一化为默认 1024
		SkipPaths:            []string{},
		SkipPathPrefixes:     []string{},
		SlowRequestThreshold: 500 * time.Millisecond,
	}
	r.Use(LoggerWithConfig(cfg))
	r.POST("/", func(c *gin.Context) {
		body, _ := io.ReadAll(c.Request.Body)
		c.Data(200, "text/plain", body)
	})

	// 请求体 5000 字节（> 默认 1024），下游应仍得完整 body
	reqBody := bytes.Repeat([]byte("a"), 5000)
	w := httptest.NewRecorder()
	req := httptest.NewRequest("POST", "/", bytes.NewReader(reqBody))
	r.ServeHTTP(w, req)

	if w.Body.Len() != len(reqBody) {
		t.Fatalf("downstream body len = %d, want %d (请求体必须完整复原)", w.Body.Len(), len(reqBody))
	}
	if !bytes.Equal(w.Body.Bytes(), reqBody) {
		t.Fatalf("downstream body corrupted")
	}
}

func TestLoggerSkipPathPrefixesAnchorsBoundary_M8(t *testing.T) {
	cfg := LoggerConfig{SkipPathPrefixes: []string{"/api"}}
	if !shouldSkipPath("/api", cfg) {
		t.Fatal("/api should be skipped")
	}
	if !shouldSkipPath("/api/users", cfg) {
		t.Fatal("/api/users should be skipped")
	}
	if shouldSkipPath("/api2/users", cfg) {
		t.Fatal("/api2/users should not be skipped by /api prefix")
	}
}