Files
hfb_sys/backend/internal/middleware/auth_test.go
T

114 lines
3.8 KiB
Go

package middleware
import (
"context"
"net/http"
"net/http/httptest"
"testing"
"hfb_sys/backend/internal/modules/auth"
"hfb_sys/backend/internal/tenancy"
"github.com/gin-gonic/gin"
)
func useRequestTenant(tenantID uint64) gin.HandlerFunc {
return func(c *gin.Context) {
ctx := tenancy.WithScope(c.Request.Context(), tenancy.Scope{TenantID: tenantID})
c.Request = c.Request.WithContext(ctx)
c.Next()
}
}
func TestUserAuthRejectsQueryToken(t *testing.T) {
gin.SetMode(gin.TestMode)
manager := auth.NewJWTManager("test-jwt-secret-for-query-token-rejection")
pair, err := manager.GenerateSubjectPairWithVersion(1, "13800000000", "user", 1)
if err != nil {
t.Fatalf("GenerateSubjectPairWithVersion() error = %v", err)
}
engine := gin.New()
engine.GET("/protected", Auth(manager, nil), func(c *gin.Context) {
c.Status(http.StatusNoContent)
})
queryRequest := httptest.NewRequest(http.MethodGet, "/protected?token="+pair.AccessToken, nil)
queryResponse := httptest.NewRecorder()
engine.ServeHTTP(queryResponse, queryRequest)
if queryResponse.Code != http.StatusUnauthorized {
t.Fatalf("query token status = %d, want %d", queryResponse.Code, http.StatusUnauthorized)
}
bearerRequest := httptest.NewRequest(http.MethodGet, "/protected", nil)
bearerRequest.Header.Set("Authorization", "Bearer "+pair.AccessToken)
bearerResponse := httptest.NewRecorder()
engine.ServeHTTP(bearerResponse, bearerRequest)
if bearerResponse.Code != http.StatusNoContent {
t.Fatalf("bearer token status = %d, want %d", bearerResponse.Code, http.StatusNoContent)
}
}
func TestAuthRejectsRevokedUserToken(t *testing.T) {
gin.SetMode(gin.TestMode)
manager := auth.NewJWTManager("test-secret")
pair, err := manager.GenerateSubjectPairWithVersion(7, "13900000007", "user", 0)
if err != nil {
t.Fatalf("生成令牌失败:%v", err)
}
engine := gin.New()
engine.GET("/protected", Auth(manager, func(_ context.Context, _ uint64, _ int64) error {
return auth.ErrTokenVersionMismatch
}), func(c *gin.Context) {
c.Status(http.StatusNoContent)
})
request := httptest.NewRequest(http.MethodGet, "/protected", nil)
request.Header.Set("Authorization", "Bearer "+pair.AccessToken)
response := httptest.NewRecorder()
engine.ServeHTTP(response, request)
if response.Code != http.StatusUnauthorized {
t.Fatalf("响应状态 = %d, want %d", response.Code, http.StatusUnauthorized)
}
}
func TestUserAndAdminTokensRejectCrossTenantRequests(t *testing.T) {
gin.SetMode(gin.TestMode)
manager := auth.NewJWTManager("cross-tenant-auth-test-secret")
userPair, err := manager.GenerateTenantPairWithVersion(1, "13800000000", "user", 1, 101)
if err != nil {
t.Fatal(err)
}
adminPair, err := manager.GenerateTenantPairWithVersion(2, "admin", "admin", 1, 101)
if err != nil {
t.Fatal(err)
}
userEngine := gin.New()
userEngine.Use(useRequestTenant(202))
userEngine.GET("/protected", Auth(manager, nil), func(c *gin.Context) {
c.Status(http.StatusNoContent)
})
userRequest := httptest.NewRequest(http.MethodGet, "/protected", nil)
userRequest.Header.Set("Authorization", "Bearer "+userPair.AccessToken)
userResponse := httptest.NewRecorder()
userEngine.ServeHTTP(userResponse, userRequest)
if userResponse.Code != http.StatusUnauthorized {
t.Fatalf("cross-tenant user token status = %d, want 401", userResponse.Code)
}
adminEngine := gin.New()
adminEngine.Use(useRequestTenant(202))
adminEngine.GET("/protected", AdminAuth(manager, nil), func(c *gin.Context) {
c.Status(http.StatusNoContent)
})
adminRequest := httptest.NewRequest(http.MethodGet, "/protected", nil)
adminRequest.Header.Set("Authorization", "Bearer "+adminPair.AccessToken)
adminResponse := httptest.NewRecorder()
adminEngine.ServeHTTP(adminResponse, adminRequest)
if adminResponse.Code != http.StatusUnauthorized {
t.Fatalf("cross-tenant admin token status = %d, want 401", adminResponse.Code)
}
}