Comment puis-je obtenir une couverture de test à 100 % lors de l'utilisation de « os.Exit() » dans Go ?

Test des scénarios os.Exit dans Go avec informations de couverture

Test des scénarios dans lesquels os.Exit() est appelé peut être difficile dans Go, car l'interception directe de os.Exit() n'est pas réalisable. L'approche courante consiste à réinvoquer le binaire et à vérifier sa valeur de sortie. Cependant, cette méthode présente des limites, notamment :

• Incompatibilité avec les tests de couverture (Coveralls/Coveralls.io) : les frameworks de tests de couverture peuvent ne pas enregistrer les tests impliquant os.Exit(), conduisant à des rapports de couverture inexacts.
• Fragilité potentielle de la réexécution du test Binaire

Naviguer dans les défis

Pour relever ces défis, une légère refactorisation peut assurer une couverture à 100 % :

Modifié Code

• foo/bar.go :

package foo

import (
    "fmt"
    "os"
)

// Expose os.Exit as a variable for unit testing
var osExit = os.Exit

func Crasher() {
    fmt.Println("Going down in flames!")
    osExit(1)
}

• foo/bar_test.go :

package foo

import (
    "testing"
    "reflect"
)

func TestCrasher(t *testing.T) {
    // Save and restore the original os.Exit() function
    oldOsExit := osExit
    defer func() { osExit = oldOsExit }()

    // Define a mock exit function that captures the exit code
    var got int
    myExit := func(code int) {
        got = code
    }

    // Set the mock exit function as os.Exit()
    osExit = myExit
    Crasher()  // Call the function being tested

    // Assert that the expected exit code was returned
    if exp := 1; got != exp {
        t.Errorf("Expected exit code: %d, got: %d", exp, got)
    }
}

En exécutant go test -cover, le rapport de couverture sera désormais reflètent avec précision l'exécution de Crasher() et sa condition de sortie.

Extension à d'autres fonctions

La même technique peut être appliquée pour tester d'autres fonctions qui peuvent appeler os. Exit() en interne, comme log.Fatalf(). Moquez-vous simplement de la fonction et affirmez son comportement approprié :

• foo/bar.go :

var logFatalf = log.Fatalf

func Crasher() {
    fmt.Println("Going down in flames!")
    logFatalf("Exiting with code: %d", 1)
}

• foo /bar_test.go :

func TestCrasher(t *testing.T) {
    // Save and restore the original log.Fatalf() function
    oldLogFatalf := logFatalf
    defer func() { logFatalf = oldLogFatalf }()

    // Define a mock fatalf function that captures the arguments
    var gotFormat string
    var gotV []interface{}
    myFatalf := func(format string, v ...interface{}) {
        gotFormat, gotV = format, v
    }

    // Set the mock fatalf function as log.Fatalf()
    logFatalf = myFatalf
    Crasher() // Call the function being tested

    // Assert that the expected format string and arguments were used
    expFormat, expV := "Exiting with code: %d", []interface{}{1}
    if gotFormat != expFormat || !reflect.DeepEqual(gotV, expV) {
        t.Error("Something went wrong")
    }
}

Avec cette approche, vous pouvez complètement testez les scénarios os.Exit dans Go et obtenez des informations de couverture précises à partir de vos frameworks de test.

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!