Problème d'erreur simple dans les tests unitaires Golang

Les tests unitaires Golang sont un moyen important pour garantir la qualité du code et l'exactitude fonctionnelle, mais dans la pratique, nous rencontrons souvent des erreurs simples. Dans cet article, l'éditeur PHP Zimo vous présentera quelques problèmes d'erreur courants et comment les résoudre. En apprenant les solutions à ces problèmes, je pense que tout le monde peut effectuer les tests unitaires Golang plus facilement et améliorer la qualité et la fiabilité du code.

Contenu de la question

J'ai un problème en essayant de tester cette fonction mais il y a une erreur à l'intérieur. Ci-dessous se trouve ma fonction réponsejson qui ne renvoie pas d'erreur mais envoie la réponse json.

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
    }
    
}

Ce qui suit est mon code de test unitaire qui crée un rédacteur de réponse fictif qui teste avec succès le rédacteur répondant à json sans erreur. Puisque je ne renvoie pas le type d'erreur dans la fonction réponsejson(), comment puis-je le tester dans la fonction test_responsejson comme ci-dessous ?

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)
        }
    }
}

De plus, j'ai créé une fonction qui génère la sortie réelle du journal pour la fonction intégrée log.println(). Je sais que la fonction log.println() est une fonction intégrée et qu'il est peu probable qu'elle échoue. Cependant, je souhaite atteindre une couverture de 100 % dans mes tests unitaires. s'il vous plaît, aidez-moi ! Merci :)

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
}

Solution

En termes simples, nous pouvons écrire un cas de test pour la fonction responsejson comme indiqué ci-dessous.

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)
    }
}

Nous ne pouvons pas revenir de bs 获取错误，err := json.marshal(jsonstatus)。 json.marshal Il existe deux types d'erreurs que les fonctions peuvent renvoyer.

1. unsupportedtypeerror (par exemple canaux, valeurs composites et valeurs de fonction)
2. unsupportedvalueerror (par exemple : structure de données circulaire)

Nous n'avons pas pu analyser la valeur pour générer l'une des erreurs ci-dessus. Nous analysons une structure avec des valeurs et des types pris en charge. Par conséquent, nous ne pouvons pas rédiger de tests avec une couverture à 100 %.

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!