Explorez quelques bibliothèques de tests populaires dans Golang

Golang est un langage de programmation relativement jeune, mais il est déjà très populaire parmi les développeurs. Parce qu'il est particulièrement adapté à la création de services Web hautes performances, mais qu'il est également fiable et simple. Pour un développeur expérimenté, écrire du code n'est pas difficile, mais comment garantir la qualité du programme lors de l'écriture du code, en particulier comment tester le code, est une question clé.

Cet article explorera comment effectuer des tests dans Golang Nous présenterons les tests unitaires et les tests d'intégration. Dans le même temps, nous explorerons également certaines bibliothèques de tests populaires, notamment test et goconvey.

Qu'est-ce que les tests unitaires ?

Les tests unitaires font référence aux développeurs qui testent les plus petites unités testables de logiciels pour s'assurer qu'elles fonctionnent correctement. En Golang, cela fait généralement référence aux fonctions et aux méthodes.

Les tests unitaires sont automatisés, ce qui signifie que vous devez écrire du code pour tester votre code. Le code sera ensuite exécuté et un rapport d'erreur détaillé sera fourni si le test échoue. Les tests étant automatisés, vous pouvez les exécuter sans intervention manuelle.

Regardons un exemple. Disons que nous avons un fichier appelé « adder.go » qui contient une fonction appelée « Add() » qui ajoute deux nombres. Voici le contenu de "adder_test.go", qui est utilisé pour tester la fonction "Add()" dans "adder.go" :

package main

import (
    "testing"
)

func TestAdd(t *testing.T) {
    expected := 4
    actual := Add(2, 2)

    if actual != expected {
        t.Errorf("Add(): expected %d but got %d", expected, actual)
    }
}

L'objectif des tests unitaires est de tester le comportement de la fonction et si elle est conforme au comportement attendu. En plus de tester si la fonction « Add() » calcule correctement la somme de deux nombres, nous testons également si elle correspond à la valeur attendue. Si le test échoue, nous verrons un message d'erreur montrant le résultat que nous recherchons afin que nous puissions facilement trouver le bug et le corriger.

Qu'est-ce que les tests d'intégration ?

Les tests d'intégration font référence au type de tests logiciels utilisés pour tester plusieurs composants afin de vérifier l'interaction entre eux. Pour les applications Web, cela implique généralement des tests de bout en bout du serveur pour garantir que le service Web est entièrement intégré et prêt à être exécuté dans un environnement réel.

Dans Golang, les tests d'intégration impliquent généralement de tester les gestionnaires HTTP ou les méthodes RPC. Vous trouverez ci-dessous le code d'un exemple de test d'intégration, qui teste si la fonction de gestionnaire HTTP peut gérer correctement les requêtes HTTP :

package main

import (
    "io/ioutil"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestHelloHandler(t *testing.T) {
    req, err := http.NewRequest("GET", "/", nil)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(HelloHandler)

    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    expected := "Hello, World!"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

Pour les tests d'intégration, nous utilisons généralement le package httptest pour gérer de telles requêtes. Cela nous permet de créer une requête HTTP factice et de la transmettre via le service Web que nous souhaitons tester.

Bibliothèque de tests dans Golang

testing

testing est le cadre de test officiel du langage Go. Le framework est intégré à la bibliothèque standard du langage Go et ne nécessite donc aucune importation supplémentaire. Il fournit quelques fonctions et types simples pour l’écriture de tests unitaires et d’intégration.

Ce qui suit est un exemple de code de la bibliothèque de tests, qui teste une fonction appelée "Square()" :

package main

import (
    "testing"
)

func TestSquare(t *testing.T) {
    cases := []struct {
        name         string
        input, want  int
    }{
        {
            "positive",
            3,
            9,
        },
        {
            "zero",
            0,
            0,
        },
        {
            "negative",
            -2,
            4,
        },
    }

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            got := Square(tc.input)
            if got != tc.want {
                t.Errorf("For (%d), got (%d), expected (%d)",
                    tc.input, got, tc.want)
            }
        })
    }
}

Maintenant, la bibliothèque de tests nous fournit une fonction pratique qui nous permet d'exécuter le même test avec plusieurs cas de test équation. Il s'agit de la fonction t.Run(), qui va créer un test enfant et l'associer à notre test parent. Quelle version de Square() a été la plus performante dans tous les cas de test ? Nous pouvons le découvrir en exécutant des tests séparés pour chaque cas de test avec t.Run().

goconvey

goconvey est un framework de test tiers populaire qui vous permet de tester le fonctionnement des fonctions et des méthodes et de comprendre rapidement quels tests réussissent et lesquels échouent.

Contrairement aux bibliothèques de test, goconvey vous permet de créer le contexte de votre code de test en copiant du texte, plutôt qu'en créant une fonction. Cela signifie que vous n'êtes pas obligé d'écrire le même code de scénario de test à chaque fois. goconvey génère automatiquement des tests et fournit un résumé des résultats, ce qui facilite son utilisation.

Voici un exemple de code du framework goconvey, qui teste une fonction appelée "Greet()" :

package main

import (
    . "github.com/smartystreets/goconvey/convey"
    "testing"
)

func TestGreet(t *testing.T) {
    Convey("Given a name and a greeting message", t, func() {
        name := "John"
        greeting := "Hello"

        Convey("When we pass the name and greeting to Greet()", func() {
            message, err := Greet(name, greeting)

            Convey("Then there is no error", func() {
                So(err, ShouldBeNil)

                Convey("And the message contains the name and greeting", func() {
                    So(message, ShouldEqual, "Hello, John")
                })
            })
        })
    })
}

Veuillez noter que nous avons utilisé "Convey" au lieu de "Run" ou "Test" pour décrire le scénario que nous souhaitons test . En effet, goconvey utilise un style de développement axé sur le comportement. Dans notre exemple, « Convey() » est une fonction qui décrit un scénario de test unitaire. Chaque scénario décrit une situation différente qui pourrait se produire et définit les résultats à vérifier. Semblable à la bibliothèque de tests, nous pouvons utiliser des fonctions telles que So/ShouldBeNil pour modifier les résultats et garantir que nos attentes sont satisfaites.

Conclusion

Les tests unitaires et les tests d'intégration font partie intégrante du processus de développement de Golang. Ils aident à garantir que notre code fonctionne comme prévu. testing et goconvey sont deux bibliothèques puissantes qui fournissent des fonctions et des types rapides et faciles à utiliser pour tester les fonctions et les méthodes. Si vous n'avez pas utilisé ces bibliothèques et souhaitez en savoir plus sur les tests dans Go, essayez-les.

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!