Vérification de l'ordre d'exécution des middlewares

La bibliothèque Alice suit un modèle de file d'attente (FIFO) pour l'exécution des middlewares. Il est crucial de s'assurer que l'ordre défini lors de la création de la chaîne est strictement respecté lors du traitement des requêtes HTTP. Une technique efficace consiste à utiliser des middlewares "marqueurs" qui injecetnt des identifiants uniques dans le corps de la réponse.

// Exemple de validation de l'ordonnancement
func TestMiddlewareSequence(t *testing.T) {
    createMarker := func(id string) alice.Constructor {
        return func(next http.Handler) http.Handler {
            return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                w.Write([]byte(id + "-"))
                next.ServeHTTP(w, r)
            })
        }
    }

    finalHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("end"))
    })

    chain := alice.New(createMarker("A"), createMarker("B"), createMarker("C")).Then(finalHandler)
    
    recorder := httptest.NewRecorder()
    req, _ := http.NewRequest("GET", "/", nil)
    chain.ServeHTTP(recorder, req)

    if recorder.Body.String() != "A-B-C-end" {
        t.Errorf("Ordre incorrect : obtenu %s", recorder.Body.String())
    }
}

Gestion des chaînes vides et des valeurs nulles

Le comportement aux limites est un point de défaillance classique. Vous devez vérifier que l'appel à une chaîne vide renvoie directement le gestionnaire final sans altération. De plus, Alice traite un paramètre nil dans la méthode Then() en utilisant par défaut http.DefaultServeMux.

func TestEmptyChainBehavior(t *testing.T) {
    handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
    
    // Une chaîne vide doit retourner le handler original
    chain := alice.New().Then(handler)
    
    if reflect.ValueOf(chain).Pointer() != reflect.ValueOf(handler).Pointer() {
        t.Error("La chaîne vide devrait être identique au handler initial")
    }
}

Validation de l'immuabiilté lors de l'extension

Les méthodes Append et Extend ne modifient pas la chaîne existante mais en retournent une nouvelle. Vos tests doivent confirmer que la chaîne parente reste intacte après une dérivation.

func TestChainImmutability(t *testing.T) {
    base := alice.New(middlewareOne)
    extended := base.Append(middlewareTwo)
    
    if len(extractConstructors(base)) != 1 {
        t.Error("La chaîne de base a été modifiée par erreur")
    }
    
    if len(extractConstructors(extended)) != 2 {
        t.Error("L'extension n'a pas produit le nombre attendu de middlewares")
    }
}

Tests de conversion avec ThenFunc

Alice facilite l'intégration de fonctions simples via ThenFunc. Il est nécessaire de tester que cette méthode convertit correctement un http.HandlerFunc en un http.Handler fonctionnel tout en préservant le comportement du middleware.

func TestThenFuncConversion(t *testing.T) {
    wasCalled := false
    funcHandler := func(w http.ResponseWriter, r *http.Request) {
        wasCalled = true
    }

    h := alice.New().ThenFunc(funcHandler)
    
    recorder := httptest.NewRecorder()
    req, _ := http.NewRequest("GET", "/", nil)
    h.ServeHTTP(recorder, req)

    if !wasCalled {
        t.Error("Le HandlerFunc n'a pas été exécuté par ThenFunc")
    }
}

Tests d'intégration avec httptest

Pour valider l'interaction réelle entre les en-têtes, les cookies et le corps de la réponse à travers toute la pile de middlewares, utilisez le package net/http/httptest. Cela permet de simuler un cycle de requête-réponse complet.

func TestFullIntegration(t *testing.T) {
    mw := func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("X-Custom-Header", "active")
            next.ServeHTTP(w, r)
        })
    }

    final := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusAccepted)
    })

    stack := alice.New(mw).Then(final)
    res := httptest.NewRecorder()
    req := httptest.NewRequest("POST", "/process", nil)

    stack.ServeHTTP(res, req)

    if res.Code != http.StatusAccepted {
        t.Errorf("Code d'état attendu 202, obtenu %d", res.Code)
    }
    if res.Header().Get("X-Custom-Header") != "active" {
        t.Error("Le middleware n'a pas correctement injecté l'en-tête")
    }
}

Analyse de la couverture et intégration continue

L'utilisation de l'outil de couverture de Go permet d'identifier les chemins logiques non testés au sein de vos constructeurs de middleware. Une attention particulière doit être portée aux middlewares conditionnels ou à ceux gérant des erreurs spécifiques (comme la récupération après panique).

# Exécution des tests avec génération de profil de couverture
go test -v -coverprofile=cnt.out ./...
# Visualisation des résultats dans le navigateur
go tool cover -html=cnt.out

L'intégration de ces tests dans un pipeline CI assure que toute nouvelle modification de la logique de routage ou des middlewares globaux ne brise pas l'ordre d'exécution ou les fonctionnalités crtiiques de l'application.