chore: 初始化仓库，排除二进制文件和覆盖率文件

internal/middleware/auth.go

@@ -0,0 +1,78 @@
+package middleware
+
+import (
+	"net/http"
+	"strings"
+
+	"carrotskin/pkg/auth"
+	
+	"github.com/gin-gonic/gin"
+)
+
+// AuthMiddleware JWT认证中间件
+func AuthMiddleware() gin.HandlerFunc {
+	return gin.HandlerFunc(func(c *gin.Context) {
+		jwtService := auth.MustGetJWTService()
+		
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"code":    401,
+				"message": "缺少Authorization头",
+			})
+			c.Abort()
+			return
+		}
+
+		// Bearer token格式
+		tokenParts := strings.SplitN(authHeader, " ", 2)
+		if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"code":    401,
+				"message": "无效的Authorization头格式",
+			})
+			c.Abort()
+			return
+		}
+
+		token := tokenParts[1]
+		claims, err := jwtService.ValidateToken(token)
+		if err != nil {
+			c.JSON(http.StatusUnauthorized, gin.H{
+				"code":    401,
+				"message": "无效的token",
+			})
+			c.Abort()
+			return
+		}
+
+		// 将用户信息存储到上下文中
+		c.Set("user_id", claims.UserID)
+		c.Set("username", claims.Username)
+		c.Set("role", claims.Role)
+
+		c.Next()
+	})
+}
+
+// OptionalAuthMiddleware 可选的JWT认证中间件
+func OptionalAuthMiddleware() gin.HandlerFunc {
+	return gin.HandlerFunc(func(c *gin.Context) {
+		jwtService := auth.MustGetJWTService()
+		
+		authHeader := c.GetHeader("Authorization")
+		if authHeader != "" {
+			tokenParts := strings.SplitN(authHeader, " ", 2)
+			if len(tokenParts) == 2 && tokenParts[0] == "Bearer" {
+				token := tokenParts[1]
+				claims, err := jwtService.ValidateToken(token)
+				if err == nil {
+					c.Set("user_id", claims.UserID)
+					c.Set("username", claims.Username)
+					c.Set("role", claims.Role)
+				}
+			}
+		}
+		c.Next()
+	})
+}

internal/middleware/auth_test.go

@@ -0,0 +1,158 @@
+package middleware
+
+import (
+	"strings"
+	"testing"
+
+	"carrotskin/pkg/auth"
+)
+
+// TestAuthMiddleware_MissingHeader 测试缺少Authorization头的情况
+// 注意：这个测试需要auth服务初始化，暂时跳过实际执行
+func TestAuthMiddleware_MissingHeader(t *testing.T) {
+	// 测试逻辑：缺少Authorization头应该返回401
+	// 由于需要auth服务初始化，这里只测试逻辑部分
+	hasHeader := false
+	if hasHeader {
+		t.Error("测试场景应该没有Authorization头")
+	}
+}
+
+// TestAuthMiddleware_InvalidFormat 测试无效的Authorization头格式
+// 注意：这个测试需要auth服务初始化，这里只测试解析逻辑
+func TestAuthMiddleware_InvalidFormat(t *testing.T) {
+	tests := []struct {
+		name      string
+		header    string
+		wantValid bool
+	}{
+		{
+			name:      "缺少Bearer前缀",
+			header:    "token123",
+			wantValid: false,
+		},
+		{
+			name:      "只有Bearer没有token",
+			header:    "Bearer",
+			wantValid: false,
+		},
+		{
+			name:      "空字符串",
+			header:    "",
+			wantValid: false,
+		},
+		{
+			name:      "错误的格式",
+			header:    "Token token123",
+			wantValid: false,
+		},
+		{
+			name:      "标准格式",
+			header:    "Bearer token123",
+			wantValid: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// 测试header解析逻辑
+			tokenParts := strings.SplitN(tt.header, " ", 2)
+			isValid := len(tokenParts) == 2 && tokenParts[0] == "Bearer"
+			if isValid != tt.wantValid {
+				t.Errorf("Header validation: got %v, want %v", isValid, tt.wantValid)
+			}
+		})
+	}
+}
+
+// TestAuthMiddleware_ValidToken 测试有效token的情况
+// 注意：这个测试需要auth服务初始化，这里只测试token格式
+func TestAuthMiddleware_ValidToken(t *testing.T) {
+	// 创建JWT服务并生成token
+	jwtService := auth.NewJWTService("test-secret-key", 24)
+	token, err := jwtService.GenerateToken(1, "testuser", "user")
+	if err != nil {
+		t.Fatalf("生成token失败: %v", err)
+	}
+
+	// 验证token格式
+	if token == "" {
+		t.Error("生成的token不应为空")
+	}
+
+	// 验证可以解析token
+	claims, err := jwtService.ValidateToken(token)
+	if err != nil {
+		t.Fatalf("验证token失败: %v", err)
+	}
+
+	if claims.UserID != 1 {
+		t.Errorf("UserID = %d, want 1", claims.UserID)
+	}
+	if claims.Username != "testuser" {
+		t.Errorf("Username = %q, want 'testuser'", claims.Username)
+	}
+}
+
+// TestOptionalAuthMiddleware_NoHeader 测试可选认证中间件无header的情况
+// 注意：这个测试需要auth服务初始化，这里只测试逻辑
+func TestOptionalAuthMiddleware_NoHeader(t *testing.T) {
+	// 测试逻辑：可选认证中间件在没有header时应该允许请求继续
+	hasHeader := false
+	shouldContinue := true // 可选认证应该允许继续
+
+	if hasHeader && !shouldContinue {
+		t.Error("可选认证逻辑错误")
+	}
+}
+
+// TestAuthMiddleware_HeaderParsing 测试Authorization头解析逻辑
+func TestAuthMiddleware_HeaderParsing(t *testing.T) {
+	tests := []struct {
+		name      string
+		header    string
+		wantValid bool
+		wantToken string
+	}{
+		{
+			name:      "标准Bearer格式",
+			header:    "Bearer token123",
+			wantValid: true,
+			wantToken: "token123",
+		},
+		{
+			name:      "Bearer后多个空格",
+			header:    "Bearer  token123",
+			wantValid: true,
+			wantToken: " token123", // SplitN只分割一次
+		},
+		{
+			name:      "缺少Bearer",
+			header:    "token123",
+			wantValid: false,
+		},
+		{
+			name:      "只有Bearer",
+			header:    "Bearer",
+			wantValid: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tokenParts := strings.SplitN(tt.header, " ", 2)
+			if len(tokenParts) == 2 && tokenParts[0] == "Bearer" {
+				if !tt.wantValid {
+					t.Errorf("应该无效但被识别为有效")
+				}
+				if tokenParts[1] != tt.wantToken {
+					t.Errorf("Token = %q, want %q", tokenParts[1], tt.wantToken)
+				}
+			} else {
+				if tt.wantValid {
+					t.Errorf("应该有效但被识别为无效")
+				}
+			}
+		})
+	}
+}

internal/middleware/cors.go

@@ -0,0 +1,22 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+)
+
+// CORS 跨域中间件
+func CORS() gin.HandlerFunc {
+	return gin.HandlerFunc(func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Credentials", "true")
+		c.Header("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+		c.Header("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	})
+}

internal/middleware/cors_test.go

@@ -0,0 +1,134 @@
+package middleware
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+// TestCORS_Headers 测试CORS中间件设置的响应头
+func TestCORS_Headers(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	router := gin.New()
+	router.Use(CORS())
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 验证CORS响应头
+	expectedHeaders := map[string]string{
+		"Access-Control-Allow-Origin":      "*",
+		"Access-Control-Allow-Credentials": "true",
+		"Access-Control-Allow-Methods":     "POST, OPTIONS, GET, PUT, DELETE",
+	}
+
+	for header, expectedValue := range expectedHeaders {
+		actualValue := w.Header().Get(header)
+		if actualValue != expectedValue {
+			t.Errorf("Header %s = %q, want %q", header, actualValue, expectedValue)
+		}
+	}
+
+	// 验证Access-Control-Allow-Headers包含必要字段
+	allowHeaders := w.Header().Get("Access-Control-Allow-Headers")
+	if allowHeaders == "" {
+		t.Error("Access-Control-Allow-Headers 不应为空")
+	}
+}
+
+// TestCORS_OPTIONS 测试OPTIONS请求处理
+func TestCORS_OPTIONS(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	router := gin.New()
+	router.Use(CORS())
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("OPTIONS", "/test", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// OPTIONS请求应该返回204状态码
+	if w.Code != http.StatusNoContent {
+		t.Errorf("OPTIONS请求状态码 = %d, want %d", w.Code, http.StatusNoContent)
+	}
+}
+
+// TestCORS_AllowMethods 测试允许的HTTP方法
+func TestCORS_AllowMethods(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	router := gin.New()
+	router.Use(CORS())
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	methods := []string{"GET", "POST", "PUT", "DELETE"}
+	for _, method := range methods {
+		t.Run(method, func(t *testing.T) {
+			req, _ := http.NewRequest(method, "/test", nil)
+			w := httptest.NewRecorder()
+
+			router.ServeHTTP(w, req)
+
+			// 验证允许的方法头包含该方法
+			allowMethods := w.Header().Get("Access-Control-Allow-Methods")
+			if allowMethods == "" {
+				t.Error("Access-Control-Allow-Methods 不应为空")
+			}
+		})
+	}
+}
+
+// TestCORS_AllowHeaders 测试允许的请求头
+func TestCORS_AllowHeaders(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	router := gin.New()
+	router.Use(CORS())
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	allowHeaders := w.Header().Get("Access-Control-Allow-Headers")
+	expectedHeaders := []string{"Content-Type", "Authorization", "Accept"}
+
+	for _, expectedHeader := range expectedHeaders {
+		if !contains(allowHeaders, expectedHeader) {
+			t.Errorf("Access-Control-Allow-Headers 应包含 %s", expectedHeader)
+		}
+	}
+}
+
+// 辅助函数：检查字符串是否包含子字符串（简单实现）
+func contains(s, substr string) bool {
+	if len(substr) == 0 {
+		return true
+	}
+	if len(s) < len(substr) {
+		return false
+	}
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}

internal/middleware/logger.go

@@ -0,0 +1,39 @@
+package middleware
+
+import (
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// Logger 日志中间件
+func Logger(logger *zap.Logger) gin.HandlerFunc {
+	return gin.HandlerFunc(func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		raw := c.Request.URL.RawQuery
+
+		// 处理请求
+		c.Next()
+
+		// 记录日志
+		latency := time.Since(start)
+		clientIP := c.ClientIP()
+		method := c.Request.Method
+		statusCode := c.Writer.Status()
+
+		if raw != "" {
+			path = path + "?" + raw
+		}
+
+		logger.Info("HTTP请求",
+			zap.String("method", method),
+			zap.String("path", path),
+			zap.Int("status", statusCode),
+			zap.String("ip", clientIP),
+			zap.Duration("latency", latency),
+			zap.String("user_agent", c.Request.UserAgent()),
+		)
+	})
+}

internal/middleware/logger_test.go

@@ -0,0 +1,185 @@
+package middleware
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap/zaptest"
+)
+
+// TestLogger_Middleware 测试日志中间件基本功能
+func TestLogger_Middleware(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Logger(logger))
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	start := time.Now()
+	router.ServeHTTP(w, req)
+	duration := time.Since(start)
+
+	// 验证请求成功处理
+	if w.Code != http.StatusOK {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusOK)
+	}
+
+	// 验证处理时间合理（应该很短）
+	if duration > 1*time.Second {
+		t.Errorf("处理时间过长: %v", duration)
+	}
+}
+
+// TestLogger_RequestInfo 测试日志中间件记录的请求信息
+func TestLogger_RequestInfo(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Logger(logger))
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	tests := []struct {
+		name   string
+		method string
+		path   string
+	}{
+		{
+			name:   "GET请求",
+			method: "GET",
+			path:   "/test",
+		},
+		{
+			name:   "POST请求",
+			method: "POST",
+			path:   "/test",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req, _ := http.NewRequest(tt.method, tt.path, nil)
+			w := httptest.NewRecorder()
+
+			router.ServeHTTP(w, req)
+
+			// 验证请求被正确处理
+			if w.Code != http.StatusOK && w.Code != http.StatusNotFound {
+				t.Errorf("状态码 = %d", w.Code)
+			}
+		})
+	}
+}
+
+// TestLogger_QueryParams 测试带查询参数的请求
+func TestLogger_QueryParams(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Logger(logger))
+	router.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/test?page=1&size=20", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 验证请求成功处理
+	if w.Code != http.StatusOK {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusOK)
+	}
+}
+
+// TestLogger_StatusCodes 测试不同状态码的日志记录
+func TestLogger_StatusCodes(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Logger(logger))
+
+	router.GET("/success", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+	router.GET("/notfound", func(c *gin.Context) {
+		c.JSON(http.StatusNotFound, gin.H{"message": "not found"})
+	})
+	router.GET("/error", func(c *gin.Context) {
+		c.JSON(http.StatusInternalServerError, gin.H{"message": "error"})
+	})
+
+	tests := []struct {
+		name       string
+		path       string
+		wantStatus int
+	}{
+		{
+			name:       "成功请求",
+			path:       "/success",
+			wantStatus: http.StatusOK,
+		},
+		{
+			name:       "404请求",
+			path:       "/notfound",
+			wantStatus: http.StatusNotFound,
+		},
+		{
+			name:       "500请求",
+			path:       "/error",
+			wantStatus: http.StatusInternalServerError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req, _ := http.NewRequest("GET", tt.path, nil)
+			w := httptest.NewRecorder()
+
+			router.ServeHTTP(w, req)
+
+			if w.Code != tt.wantStatus {
+				t.Errorf("状态码 = %d, want %d", w.Code, tt.wantStatus)
+			}
+		})
+	}
+}
+
+// TestLogger_Latency 测试延迟计算
+func TestLogger_Latency(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Logger(logger))
+	router.GET("/test", func(c *gin.Context) {
+		// 模拟一些处理时间
+		time.Sleep(10 * time.Millisecond)
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/test", nil)
+	w := httptest.NewRecorder()
+
+	start := time.Now()
+	router.ServeHTTP(w, req)
+	duration := time.Since(start)
+
+	// 验证延迟计算合理（应该包含处理时间）
+	if duration < 10*time.Millisecond {
+		t.Errorf("延迟计算可能不正确: %v", duration)
+	}
+}

internal/middleware/recovery.go

@@ -0,0 +1,29 @@
+package middleware
+
+import (
+	"net/http"
+	"runtime/debug"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+)
+
+// Recovery 恢复中间件
+func Recovery(logger *zap.Logger) gin.HandlerFunc {
+	return gin.CustomRecovery(func(c *gin.Context, recovered interface{}) {
+		if err, ok := recovered.(string); ok {
+			logger.Error("服务器恐慌",
+				zap.String("error", err),
+				zap.String("path", c.Request.URL.Path),
+				zap.String("method", c.Request.Method),
+				zap.String("ip", c.ClientIP()),
+				zap.String("stack", string(debug.Stack())),
+			)
+		}
+
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"code":    500,
+			"message": "服务器内部错误",
+		})
+	})
+}

internal/middleware/recovery_test.go

@@ -0,0 +1,153 @@
+package middleware
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap/zaptest"
+)
+
+// TestRecovery_PanicHandling 测试恢复中间件处理panic
+func TestRecovery_PanicHandling(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	// 创建一个会panic的路由
+	router.GET("/panic", func(c *gin.Context) {
+		panic("test panic")
+	})
+
+	req, _ := http.NewRequest("GET", "/panic", nil)
+	w := httptest.NewRecorder()
+
+	// 应该不会导致测试panic，而是返回500错误
+	router.ServeHTTP(w, req)
+
+	// 验证返回500状态码
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusInternalServerError)
+	}
+}
+
+// TestRecovery_StringPanic 测试字符串类型的panic
+func TestRecovery_StringPanic(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	router.GET("/panic", func(c *gin.Context) {
+		panic("string panic message")
+	})
+
+	req, _ := http.NewRequest("GET", "/panic", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 验证返回500状态码
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusInternalServerError)
+	}
+}
+
+// TestRecovery_ErrorPanic 测试error类型的panic
+func TestRecovery_ErrorPanic(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	router.GET("/panic", func(c *gin.Context) {
+		panic(http.ErrBodyReadAfterClose)
+	})
+
+	req, _ := http.NewRequest("GET", "/panic", nil)
+	w := httptest.NewRecorder()
+
+	// 应该不会导致测试panic
+	router.ServeHTTP(w, req)
+
+	// 验证返回500状态码
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusInternalServerError)
+	}
+}
+
+// TestRecovery_NilPanic 测试nil panic
+func TestRecovery_NilPanic(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	router.GET("/panic", func(c *gin.Context) {
+		// 直接panic模拟nil pointer错误，避免linter警告
+		panic("runtime error: invalid memory address or nil pointer dereference")
+	})
+
+	req, _ := http.NewRequest("GET", "/panic", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 验证返回500状态码
+	if w.Code != http.StatusInternalServerError {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusInternalServerError)
+	}
+}
+
+// TestRecovery_ResponseFormat 测试恢复后的响应格式
+func TestRecovery_ResponseFormat(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	router.GET("/panic", func(c *gin.Context) {
+		panic("test panic")
+	})
+
+	req, _ := http.NewRequest("GET", "/panic", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 验证响应体包含错误信息
+	body := w.Body.String()
+	if body == "" {
+		t.Error("响应体不应为空")
+	}
+}
+
+// TestRecovery_NormalRequest 测试正常请求不受影响
+func TestRecovery_NormalRequest(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	logger := zaptest.NewLogger(t)
+	router := gin.New()
+	router.Use(Recovery(logger))
+
+	router.GET("/normal", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"message": "success"})
+	})
+
+	req, _ := http.NewRequest("GET", "/normal", nil)
+	w := httptest.NewRecorder()
+
+	router.ServeHTTP(w, req)
+
+	// 正常请求应该不受影响
+	if w.Code != http.StatusOK {
+		t.Errorf("状态码 = %d, want %d", w.Code, http.StatusOK)
+	}
+}