added more comprehensive unit test cases

2025-12-16 11:18:35 +08:00
parent 7d6efecb41
commit 7e42d04fde
9 changed files with 2519 additions and 0 deletions
@@ -156,3 +156,177 @@ func TestAuthorizeHandler_NilMaps(t *testing.T) {
 	// The handler should complete without panic
 	// Status code will depend on whether permission exists in DB
 }
+
+// Additional comprehensive test cases
+
+func TestAuthorizeHandler_EmptyUserID(t *testing.T) {
+	claims := &models.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Role:     "admin",
+	}
+
+	payload := models.AuthorizationContext{
+		UserID:   "",
+		Resource: "document",
+		Action:   "read",
+	}
+
+	body, _ := json.Marshal(payload)
+	req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBuffer(body))
+	ctx := context.WithValue(req.Context(), models.ContextKey("claims"), claims)
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	AuthorizeHandler(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status %d for empty UserID, got %d", http.StatusBadRequest, w.Code)
+	}
+}
+
+func TestAuthorizeHandler_EmptyResource(t *testing.T) {
+	claims := &models.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Role:     "admin",
+	}
+
+	payload := models.AuthorizationContext{
+		UserID:   "user123",
+		Resource: "",
+		Action:   "read",
+	}
+
+	body, _ := json.Marshal(payload)
+	req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBuffer(body))
+	ctx := context.WithValue(req.Context(), models.ContextKey("claims"), claims)
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	AuthorizeHandler(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status %d for empty Resource, got %d", http.StatusBadRequest, w.Code)
+	}
+}
+
+func TestAuthorizeHandler_EmptyAction(t *testing.T) {
+	claims := &models.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Role:     "admin",
+	}
+
+	payload := models.AuthorizationContext{
+		UserID:   "user123",
+		Resource: "document",
+		Action:   "",
+	}
+
+	body, _ := json.Marshal(payload)
+	req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBuffer(body))
+	ctx := context.WithValue(req.Context(), models.ContextKey("claims"), claims)
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	AuthorizeHandler(w, req)
+
+	if w.Code != http.StatusBadRequest {
+		t.Errorf("Expected status %d for empty Action, got %d", http.StatusBadRequest, w.Code)
+	}
+}
+
+func TestAuthorizeHandler_InvalidClaimsType(t *testing.T) {
+	req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBufferString(`{"userId":"user123","resource":"doc","action":"read"}`))
+
+	// Set claims as wrong type
+	ctx := context.WithValue(req.Context(), models.ContextKey("claims"), "invalid_claims_type")
+	req = req.WithContext(ctx)
+	w := httptest.NewRecorder()
+
+	AuthorizeHandler(w, req)
+
+	if w.Code != http.StatusUnauthorized {
+		t.Errorf("Expected status %d for invalid claims type, got %d", http.StatusUnauthorized, w.Code)
+	}
+}
+
+func TestAuthorizeHandler_MalformedJSON(t *testing.T) {
+	claims := &models.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Role:     "admin",
+	}
+
+	testCases := []struct {
+		name    string
+		payload string
+	}{
+		{"Incomplete JSON", `{"userId":"user123","resource":"doc"`},
+		{"Invalid quotes", `{userId:"user123"}`},
+		{"Trailing comma", `{"userId":"user123",}`},
+		{"Just whitespace", `   `},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBufferString(tc.payload))
+			ctx := context.WithValue(req.Context(), models.ContextKey("claims"), claims)
+			req = req.WithContext(ctx)
+			w := httptest.NewRecorder()
+
+			AuthorizeHandler(w, req)
+
+			if w.Code != http.StatusBadRequest {
+				t.Errorf("Expected status %d for malformed JSON, got %d", http.StatusBadRequest, w.Code)
+			}
+		})
+	}
+}
+
+func TestAuthorizeHandler_SpecialCharactersInFields(t *testing.T) {
+	t.Skip("Skipping - requires database mock setup")
+
+	testCases := []struct {
+		name     string
+		userID   string
+		resource string
+		action   string
+	}{
+		{"Special chars in resource", "user123", "document/file-name_v1.2", "read"},
+		{"Unicode in resource", "user123", "文档", "read"},
+		{"Spaces in action", "user123", "document", "read write"},
+		{"Special chars in userID", "user-123_test", "document", "read"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			payload := models.AuthorizationContext{
+				UserID:   tc.userID,
+				Resource: tc.resource,
+				Action:   tc.action,
+			}
+
+			body, _ := json.Marshal(payload)
+			req := httptest.NewRequest("POST", "/v1/auth/check", bytes.NewBuffer(body))
+
+			// Update claims to match userID
+			testClaims := &models.Claims{
+				UserID:   tc.userID,
+				Username: "testuser",
+				Role:     "admin",
+			}
+			ctx := context.WithValue(req.Context(), models.ContextKey("claims"), testClaims)
+			req = req.WithContext(ctx)
+			w := httptest.NewRecorder()
+
+			AuthorizeHandler(w, req)
+
+			// Should handle special characters without crashing
+			if w.Code == 0 {
+				t.Error("Handler did not set response status")
+			}
+		})
+	}
+}
@@ -214,3 +214,196 @@ func TestReadyHandler_ContentType(t *testing.T) {
 		t.Errorf("Content-Type = %v, want application/json", contentType)
 	}
 }
+
+// Additional comprehensive test cases
+
+func TestHealthHandler_MultipleRequests(t *testing.T) {
+	// Test that multiple concurrent requests work correctly
+	concurrency := 10
+	done := make(chan bool, concurrency)
+
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			req := httptest.NewRequest(http.MethodGet, "/health", nil)
+			w := httptest.NewRecorder()
+			HealthHandler(w, req)
+
+			if w.Code != http.StatusOK {
+				t.Errorf("Expected status 200, got %d", w.Code)
+			}
+			done <- true
+		}()
+	}
+
+	for i := 0; i < concurrency; i++ {
+		<-done
+	}
+}
+
+func TestHealthHandler_DifferentMethods(t *testing.T) {
+	methods := []string{"GET", "POST", "PUT", "DELETE", "PATCH"}
+
+	for _, method := range methods {
+		t.Run(method, func(t *testing.T) {
+			req := httptest.NewRequest(method, "/health", nil)
+			w := httptest.NewRecorder()
+			HealthHandler(w, req)
+
+			// Handler should always return 200 OK regardless of method
+			if w.Code != http.StatusOK {
+				t.Errorf("Expected status 200 for method %s, got %d", method, w.Code)
+			}
+		})
+	}
+}
+
+func TestHealthHandler_ResponseFormat(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/health", nil)
+	w := httptest.NewRecorder()
+	HealthHandler(w, req)
+
+	var response models.HealthResponse
+	if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+		t.Fatalf("Failed to decode response: %v", err)
+	}
+
+	if response.Status == "" {
+		t.Error("Status field should not be empty")
+	}
+
+	if response.Status != "ok" {
+		t.Errorf("Expected status 'ok', got '%s'", response.Status)
+	}
+}
+
+func TestReadyHandler_DatabaseTimeout(t *testing.T) {
+	mockDB, mock, err := sqlmock.New(sqlmock.MonitorPingsOption(true))
+	if err != nil {
+		t.Fatalf("failed to create mock db: %v", err)
+	}
+	defer mockDB.Close()
+
+	// Simulate timeout by expecting ping but not responding properly
+	mock.ExpectPing().WillDelayFor(5 * 1000000000) // 5 seconds
+
+	originalDB := db.DB
+	db.DB = mockDB
+	defer func() { db.DB = originalDB }()
+
+	originalRedis := redisclient.RDB
+	redisclient.RDB = nil
+	defer func() { redisclient.RDB = originalRedis }()
+
+	req := httptest.NewRequest(http.MethodGet, "/ready", nil)
+	w := httptest.NewRecorder()
+
+	// This should timeout and return unhealthy
+	ReadyHandler(w, req)
+
+	if w.Code != http.StatusServiceUnavailable {
+		t.Logf("Expected status 503, got %d (timeout may have been handled differently)", w.Code)
+	}
+}
+
+func TestReadyHandler_BothServicesHealthy(t *testing.T) {
+	// This test would require both real DB and Redis mocks
+	// Skip for now as it's complex to set up both simultaneously
+	t.Skip("Skipping - requires both DB and Redis mock setup")
+}
+
+func TestReadyHandler_NilDatabaseAndRedis(t *testing.T) {
+	originalDB := db.DB
+	db.DB = nil
+	defer func() { db.DB = originalDB }()
+
+	originalRedis := redisclient.RDB
+	redisclient.RDB = nil
+	defer func() { redisclient.RDB = originalRedis }()
+
+	req := httptest.NewRequest(http.MethodGet, "/ready", nil)
+	w := httptest.NewRecorder()
+
+	ReadyHandler(w, req)
+
+	if w.Code != http.StatusServiceUnavailable {
+		t.Errorf("Expected status 503 when both services are nil, got %d", w.Code)
+	}
+
+	var response models.HealthResponse
+	if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+		t.Fatalf("Failed to decode response: %v", err)
+	}
+
+	if response.Status != "unhealthy" && response.Status != "degraded" {
+		t.Errorf("Expected status 'unhealthy' or 'degraded', got '%s'", response.Status)
+	}
+}
+
+func TestReadyHandler_ResponseStructure(t *testing.T) {
+	originalDB := db.DB
+	db.DB = nil
+	defer func() { db.DB = originalDB }()
+
+	originalRedis := redisclient.RDB
+	redisclient.RDB = nil
+	defer func() { redisclient.RDB = originalRedis }()
+
+	req := httptest.NewRequest(http.MethodGet, "/ready", nil)
+	w := httptest.NewRecorder()
+
+	ReadyHandler(w, req)
+
+	// Verify response is valid JSON
+	var response map[string]interface{}
+	if err := json.NewDecoder(w.Body).Decode(&response); err != nil {
+		t.Fatalf("Failed to decode response: %v", err)
+	}
+
+	// Check that response has expected fields
+	if _, ok := response["status"]; !ok {
+		t.Error("Response should have 'status' field")
+	}
+}
+
+func TestHealthHandler_WithCustomHeaders(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/health", nil)
+	req.Header.Set("X-Request-ID", "test-123")
+	req.Header.Set("User-Agent", "Test-Agent/1.0")
+
+	w := httptest.NewRecorder()
+	HealthHandler(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status 200, got %d", w.Code)
+	}
+}
+
+func TestReadyHandler_ConcurrentRequests(t *testing.T) {
+	originalDB := db.DB
+	db.DB = nil
+	defer func() { db.DB = originalDB }()
+
+	originalRedis := redisclient.RDB
+	redisclient.RDB = nil
+	defer func() { redisclient.RDB = originalRedis }()
+
+	concurrency := 20
+	done := make(chan bool, concurrency)
+
+	for i := 0; i < concurrency; i++ {
+		go func() {
+			req := httptest.NewRequest(http.MethodGet, "/ready", nil)
+			w := httptest.NewRecorder()
+			ReadyHandler(w, req)
+
+			if w.Code != http.StatusServiceUnavailable && w.Code != http.StatusOK {
+				t.Errorf("Expected status 503 or 200, got %d", w.Code)
+			}
+			done <- true
+		}()
+	}
+
+	for i := 0; i < concurrency; i++ {
+		<-done
+	}
+}