96 lines
3.6 KiB
Go
96 lines
3.6 KiB
Go
package handlers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/zap/zaptest"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// TestHealthHandler_Readiness_DegradedMode vérifie que /readyz retourne "degraded" si Redis/RabbitMQ down
|
|
// MOD-P1-006: Test pour valider que /readyz tolère Redis/RabbitMQ down
|
|
func TestHealthHandler_Readiness_DegradedMode(t *testing.T) {
|
|
// Créer une DB SQLite en mémoire pour le test
|
|
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
|
|
if err != nil {
|
|
t.Skipf("SQLite not available: %v", err)
|
|
}
|
|
|
|
logger := zaptest.NewLogger(t)
|
|
|
|
// Créer un handler avec Redis/RabbitMQ nil (simule services down)
|
|
handler := NewHealthHandler(db, logger, nil, nil, "test")
|
|
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
router.GET("/readyz", handler.Readiness)
|
|
|
|
req, _ := http.NewRequest("GET", "/readyz", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
// MOD-P1-006: /readyz doit retourner 200 OK même si Redis/RabbitMQ down (degraded)
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
// Vérifier que la réponse contient "degraded" ou "ready"
|
|
// Note: RespondSuccess wrap la réponse dans {"success": true, "data": {...}}
|
|
var responseWrapper map[string]interface{}
|
|
err = json.Unmarshal(w.Body.Bytes(), &responseWrapper)
|
|
require.NoError(t, err)
|
|
|
|
// Extraire la réponse data
|
|
data, ok := responseWrapper["data"].(map[string]interface{})
|
|
require.True(t, ok, "Response should have 'data' field")
|
|
|
|
// MOD-P1-006: Status doit être "degraded" si Redis/RabbitMQ down, ou "ready" si DB OK
|
|
// (Dans ce test, DB est OK mais Redis/RabbitMQ sont nil, donc devrait être "degraded")
|
|
// Note: Le comportement exact dépend de l'implémentation de checkRedis/checkRabbitMQ
|
|
// Si ces checks retournent "error" quand nil, alors status devrait être "degraded"
|
|
status, ok := data["status"].(string)
|
|
require.True(t, ok, "Response should have 'status' field")
|
|
assert.Contains(t, []string{"ready", "degraded"}, status, "Status should be 'ready' or 'degraded'")
|
|
|
|
// Vérifier que les checks sont présents
|
|
checks, ok := data["checks"].(map[string]interface{})
|
|
require.True(t, ok, "Response should have 'checks' field")
|
|
assert.Contains(t, checks, "database", "Should have database check")
|
|
}
|
|
|
|
// TestHealthHandler_Readiness_DatabaseCritical vérifie que /readyz retourne "not_ready" si DB down
|
|
// MOD-P1-006: Test pour valider que DB est critique (not_ready si DB down)
|
|
func TestHealthHandler_Readiness_DatabaseCritical(t *testing.T) {
|
|
// Créer une DB SQLite invalide (fermée) pour simuler DB down
|
|
// Note: SQLite en mémoire ne peut pas vraiment simuler une DB down
|
|
// Ce test vérifie juste que le handler gère correctement les erreurs DB
|
|
|
|
logger := zaptest.NewLogger(t)
|
|
|
|
// Créer un handler avec DB nil (simule DB down)
|
|
handler := NewHealthHandler(nil, logger, nil, nil, "test")
|
|
|
|
gin.SetMode(gin.TestMode)
|
|
router := gin.New()
|
|
router.GET("/readyz", handler.Readiness)
|
|
|
|
req, _ := http.NewRequest("GET", "/readyz", nil)
|
|
w := httptest.NewRecorder()
|
|
router.ServeHTTP(w, req)
|
|
|
|
// MOD-P1-006: /readyz doit retourner 503 Service Unavailable si DB down (not_ready)
|
|
assert.Equal(t, http.StatusServiceUnavailable, w.Code)
|
|
|
|
// Vérifier que la réponse contient "not_ready"
|
|
// Note: Si DB down, le handler retourne directement c.JSON() sans RespondSuccess
|
|
var response HealthResponse
|
|
err := json.Unmarshal(w.Body.Bytes(), &response)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "not_ready", response.Status, "Status should be 'not_ready' if DB down")
|
|
}
|