Einfaches Fehlerproblem beim Golang-Unit-Testen

Golang-Unit-Tests sind ein wichtiges Mittel, um die Codequalität und funktionale Korrektheit sicherzustellen, aber in der Praxis stoßen wir oft auf einige einfache Fehler. In diesem Artikel stellt Ihnen der PHP-Editor Zimo einige häufige Fehlerprobleme und deren Lösung vor. Durch das Erlernen der Lösungen für diese Probleme glaube ich, dass jeder Golang-Unit-Tests reibungsloser durchführen und die Qualität und Zuverlässigkeit des Codes verbessern kann.

Frageninhalt

Ich habe ein Problem beim Versuch, diese Funktion zu testen, aber es ist ein Fehler darin enthalten. Unten ist meine Responsejson-Funktion, die keinen Fehler zurückgibt, aber die Antwort-JSON sendet.

func responsejson(w http.responsewriter, code int, message string) {
    jsonstatus := struct {
        code int `json:"code"`
        message string `json:"message"`
    }{
        message: message,
        code: code,
    }

    bs, err := json.marshal(jsonstatus);

    if err != nil {
        log.println("error in marshal json in responsejson: ", err)
        str := "internal server error. please contact the system administrator."
        io.writestring(w, str);
        return 
    } else {
        io.writestring(w, string(bs));
        return
    }
    
}

Das Folgende ist mein Unit-Test-Code, der einen Schein-Responsewriter erstellt, der den Writer, der auf JSON antwortet, ohne Fehler erfolgreich testet. Da ich den Fehlertyp in der Funktion „responsejson()“ nicht zurückgebe, wie kann ich ihn wie unten in der Funktion „test_responsejson“ testen?

func test_responsejson(t *testing.t) {
    responsejsontests := []struct {
        testname string
        code int
        message string
        expectedjsonresponse string
    } {
        {"successful login", http.statusok, "successfully logged in!", `{"code":200,"message":"successfully logged in!"}`},
        {"existing username", http.statusbadrequest, "username already exists. please try again.", `{"code":400,"message":"username already exists. please try again."}`},
    }

    for _, e := range responsejsontests {
        // creating a mock responsewriter
        w := httptest.newrecorder()

        responsejson(w, e.code, e.message)

        // read the response body as a string
        body, _ := io.readall(w.result().body)
        actual := string(body)

        expected := e.expectedjsonresponse
        if actual != expected {
            t.errorf("%s: expected %s but got %s", e.testname, e.expectedjsonresponse, actual)
        }
    }
}

Zusätzlich habe ich eine Funktion erstellt, die die eigentliche Protokollausgabe für die integrierte Funktion log.println() generiert. Ich weiß, dass die Funktion log.println() eine integrierte Funktion ist und wahrscheinlich nicht fehlschlägt. Allerdings möchte ich bei meinen Unit-Tests eine 100-prozentige Abdeckung erreichen. Bitte helfen Sie! Danke :)

func GenerateLogOutput(message string, errorMessage string) string {
    // Create a new bytes.Buffer to capture the log output
    var buf bytes.Buffer

    // Redirect log output to a different destination set as a buffer
    // By default, log message are written to the standard error stream os.Stderr
    log.SetOutput(&buf)

    // Generate an error
    err := errors.New(errorMessage)

    w := httptest.NewRecorder()

    // Calling the function
    InternalServerError(w, message, err)
    actualOutput := buf.String()

    return actualOutput
}

Lösung

Einfach ausgedrückt können wir einen Testfall für die responsejson-Funktion schreiben, wie unten gezeigt.

func Test_ResponseJson(t *testing.T) {
    tests := []struct {
        Code        int
        Message     string
        ExpectedStr string
    }{
        {
            Code:        1,
            Message:     "sample message",
            ExpectedStr: "{\"code\":1,\"message\":\"sample message\"}",
        },
    }
    for _, test := range tests {
        w := httptest.NewRecorder()

        ResponseJson(w, test.Code, test.Message)

        res := w.Result()
        data, err := ioutil.ReadAll(res.Body)
        res.Body.Close()

        actualStr := string(data)

        assert.Nil(t, err, "Invalid test data")
        assert.Equal(t, actualStr, test.ExpectedStr)
    }
}

Wir können nicht zurückkehren von bs 获取错误，err := json.marshal(jsonstatus)。 json.marshal Es gibt zwei Arten von Fehlern, die Funktionen zurückgeben können.

1. unsupportedtypeerror (z. B. Kanäle, zusammengesetzte Werte und Funktionswerte)
2. unsupportedvalueerror (zum Beispiel: kreisförmige Datenstruktur)

Wir konnten den Wert nicht analysieren, um einen der oben genannten Fehler zu generieren. Wir analysieren eine Struktur mit unterstützten Werten und unterstützten Typen. Daher können wir keine Tests mit 100 % Abdeckung schreiben.

Das obige ist der detaillierte Inhalt vonEinfaches Fehlerproblem beim Golang-Unit-Testen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!