Comment puis-je tester efficacement les fonctions Go à l'aide de log.Fatal() ?

Test des fonctions Go avec log.Fatal()

Lors de l'écriture de fonctions Go qui utilisent log.Fatal(), les tester peut poser un défi en raison de leur arrêt immédiat du programme. Pour surmonter ce problème, nous avons besoin d'une solution qui nous permette de tester le comportement de journalisation souhaité sans interrompre l'exécution du test.

Une approche consiste à créer un enregistreur personnalisé qui remplace la fonction log.Fatal() par défaut par un autre qui enregistre le message du journal sans quitter le programme. Cet enregistreur personnalisé peut ensuite être utilisé dans le contexte de test, permettant la vérification des messages de journal attendus.

Par exemple, supposons que nous ayons une fonction qui enregistre un « Bonjour ! » » et un autre qui enregistre un message « Au revoir ! message utilisant log.Fatal().

package main

import (
    "log"
)

func hello() {
    log.Print("Hello!")
}

func goodbye() {
    log.Fatal("Goodbye!")
}

func init() {
    log.SetFlags(0)
}

func main() {
    hello()
    goodbye()
}

Pour tester ces fonctions, nous pouvons créer un enregistreur de tampon personnalisé :

package main

import (
    "bytes"
    "log"
    "testing"
)

type BufferLogger struct {
    buf bytes.Buffer
}

func (l *BufferLogger) Println(v ...interface{}) {
    l.buf.WriteString(fmt.Sprintln(v...))
}

func TestHello(t *testing.T) {
    l := &BufferLogger{}
    log.SetOutput(l)

    hello()

    wantMsg := "Hello!\n"
    msg := l.buf.String()
    if msg != wantMsg {
        t.Errorf("%#v, wanted %#v", msg, wantMsg)
    }
}

Dans ce BufferLogger personnalisé, nous redirigeons toutes les sorties de journaux vers un tampon au lieu de la console par défaut. Cela nous permet de capturer les messages du journal et de les comparer aux valeurs attendues dans notre test.

Pour la fonction goodbye(), nous pouvons créer un test similaire en remplaçant la fonction Fatal() dans notre enregistreur personnalisé pour empêcher le programme de se fermer :

func (l *BufferLogger) Fatalf(format string, v ...interface{}) {
    l.buf.WriteString(fmt.Sprintf(format, v...))
}

func TestGoodbye(t *testing.T) {
    l := &BufferLogger{}
    log.SetOutput(l)

    goodbye()

    wantMsg := "Goodbye!\n"
    msg := l.buf.String()
    if msg != wantMsg {
        t.Errorf("%#v, wanted %#v", msg, wantMsg)
    }
}

En remplaçant la fonction log.Fatal(), nous pouvons continuer l'exécution de notre test tout en capturant le message de journal attendu. Cette technique nous permet de tester de manière exhaustive nos fonctions qui utilisent log.Fatal() sans rencontrer d'arrêt prématuré du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!