Wie kann ich mit „os.Exit()' eine genaue Testabdeckung für Go-Code erreichen?

Testen von os.Exit-Szenarien in Go mit Coverage-Informationen (coveralls.io/Goveralls)

Diese Frage bezieht sich auf Testszenarien mit Betriebssystemen. Exit() in Go, insbesondere wie man Abdeckungsinformationen für diese Szenarien erfasst. Der bereitgestellte Beispielcode demonstriert eine Re-Exec-Methode, weist jedoch Einschränkungen hinsichtlich der Coverage-Tools und Fragilität auf.

Coverage-Herausforderungen

Eine Schwierigkeit besteht darin, dass Coverage-Frameworks wie z coveralls.io zeichnet möglicherweise nicht die Abdeckung von Tests auf, die os.Exit() hervorrufen. Dies liegt daran, dass die Coverage-Instrumentierung nicht angewendet wird, wenn die Testbinärdatei erneut ausgeführt wird.

Geänderte Methode zur erneuten Ausführung

Um dieses Problem zu beheben, wurde eine modifizierte exec-Methode kann verwendet werden. Der ursprüngliche Code wird umgestaltet, um os.Exit als Variable mit dem Namen osExit zu extrahieren. Der Testcode ersetzt dann osExit durch eine Scheinfunktion, die den Exit-Code aufzeichnet. Dadurch können Abdeckungsinformationen für osExit-Aufrufe erfasst werden.

Abdeckung externer Anrufe

Die gleiche Technik kann angewendet werden, um Aufrufe von Funktionen wie log.Fatalf() abzudecken. , die indirekt os.Exit aufrufen. Die logFatalf-Funktion wird durch eine Scheinfunktion ersetzt, die das Nachrichtenformat und die an sie übergebenen Argumente aufzeichnet. Dies gewährleistet die Abdeckung von Szenarien, in denen os.Exit von externen Funktionen aufgerufen wird.

Beispiel

Der geänderte Code und Test lauten wie folgt:

// bar.go
package foo

import (
    "fmt"
    "os"
)

var osExit = os.Exit

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

// bar_test.go
package foo

import (
    "reflect"
    "testing"
)

var logFatalf = log.Fatalf

func TestCrasher(t *testing.T) {
    // Save original functions and restore at the end
    oldOsExit := osExit
    oldLogFatalf := logFatalf
    defer func() {
        osExit = oldOsExit
        logFatalf = oldLogFatalf
    }()

    // Mock osExit
    var got int
    myExit := func(code int) {
        got = code
    }
    osExit = myExit

    // Mock logFatalf
    var gotFormat string
    var gotV []interface{}
    myFatalf := func(format string, v ...interface{}) {
        gotFormat, gotV = format, v
    }
    logFatalf = myFatalf

    // Run test
    Crasher()

    // Check results
    exp := 1
    if got != exp {
        t.Errorf("Expected exit code: %d, got: %d", exp, got)
    }

    expFormat, expV := "Exiting with code: %d", []interface{}{1}
    if gotFormat != expFormat || !reflect.DeepEqual(gotV, expV) {
        t.Error("Something went wrong")
    }
}

Durch die Isolierung der Exit-bezogenen Funktionalität und die Verwendung von Scheinfunktionen können sowohl os.Exit als auch externe Funktionsaufrufe, die os.Exit auslösen, abgedeckt werden in Go-Tests. Dieser Ansatz gewährleistet eine genaue Abdeckungsberichterstattung für Szenarien mit Prozessbeendigung.

Das obige ist der detaillierte Inhalt vonWie kann ich mit „os.Exit()' eine genaue Testabdeckung für Go-Code erreichen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!