Au fur et à mesure que nous développons cette API, nous avons abordé l'authentification, la journalisation, la Dockerisation, et bien plus encore. Mais une chose dont nous n’avons pas encore discuté est les tests ! Si vous souhaitez que votre API soit prête pour la production, l'ajout de tests unitaires solides est crucial. Dans cet article, nous passerons en revue les bases des tests unitaires dans Go, afin que vous puissiez détecter les bugs plus tôt et fournir du code de haute qualité.

Pourquoi les tests unitaires ?

Les tests unitaires vous aident à vérifier que chaque partie de votre base de code fonctionne comme prévu. Ils constituent votre première ligne de défense contre les bugs, les régressions et autres mauvaises surprises. Avec la bibliothèque de tests intégrée de Go, vous pouvez rapidement configurer des tests qui :

• Assurez un comportement cohérent de vos fonctions.
• Facilitez la refactorisation du code sans introduire de nouveaux problèmes.
• Améliorez votre confiance dans le fait que tout fonctionne comme il se doit.

Prêt à commencer ? Allons-y ! ?

Étape 1 : Configuration d'un test de base

Le framework de test de Go est simple et intégré directement dans le langage. Vous pouvez créer un fichier de test en le nommant avec le suffixe _test.go. Commençons par tester une fonction simple dans main.go :

// main.go
package main

func Add(a, b int) int {
    return a   b
}

Maintenant, créez un fichier nommé main_test.go et ajoutez le code suivant :

// main_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5

    if result != expected {
        t.Errorf("Add(2, 3) = %d; want %d", result, expected)
    }
}

Comment ça marche :

1. Fonction de test : toute fonction de test dans Go doit commencer par Test et accepter un paramètre *testing.T.
2. Assertion : Nous vérifions si le résultat correspond à notre attente. Si ce n'est pas le cas, nous enregistrons une erreur en utilisant t.Errorf.

Pour exécuter le test, utilisez simplement :

go test

Si tout fonctionne, vous verrez un message ok. ?

Étape 2 : tester les gestionnaires HTTP

Maintenant, écrivons un test pour l'un de nos gestionnaires HTTP. Nous utiliserons le package httptest de Go pour créer un enregistreur de requêtes et de réponses HTTP simulé.

// main_test.go
package main

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

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

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

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

Explication:

1. httptest.NewRequest : crée une nouvelle requête HTTP. Cela simule une requête adressée à votre point de terminaison /books.
2. httptest.NewRecorder : se moque d'une réponse HTTP. Nous vérifierons cela plus tard pour voir si cela correspond à nos attentes.
3. ServeHTTP : appelle notre gestionnaire getBooks avec la requête fictive et l'enregistreur.

De cette façon, vous pouvez isoler et tester vos gestionnaires sans avoir à démarrer un serveur complet. ?

Étape 3 : Exécution de tests avec couverture

Go dispose d'un moyen intégré pour vérifier la couverture des tests. Pour voir quel pourcentage de votre code est couvert par les tests, vous pouvez exécuter :

go test -cover

Pour une couverture plus détaillée, générez un rapport HTML :

go test -coverprofile=coverage.out
go tool cover -html=coverage.out

Ouvrez le fichier HTML généré pour visualiser quelles parties de votre code sont couvertes. C'est un moyen fantastique de déterminer les domaines dans lesquels vous pourriez avoir besoin de tests supplémentaires.

Étape 4 : se moquer des dépendances externes

Lorsque vous testez des fonctions qui dépendent de services externes (par exemple, une base de données ou des appels d'API externes), vous pouvez utiliser des interfaces pour simuler ces dépendances.

// Define a simple interface for our database
type Database interface {
    GetBooks() ([]Book, error)
}

// Implement a mock database
type MockDatabase struct{}

func (m MockDatabase) GetBooks() ([]Book, error) {
    return []Book{{Title: "Mock Book"}}, nil
}

En utilisant des interfaces, vous pouvez remplacer la dépendance réelle par votre maquette pendant les tests. Vos tests restent ainsi rapides, isolés et reproductibles.

Quelle est la prochaine étape ?

Maintenant que vous avez commencé à créer des tests unitaires, essayez d'ajouter des tests à d'autres parties de votre API ! ? La semaine prochaine, nous examinerons l'intégration d'un pipeline CI/CD afin que ces tests puissent s'exécuter automatiquement à chaque modification. Restez à l'écoute!

Question pour vous : Quel est votre outil ou technique de test préféré ? Déposez un commentaire ci-dessous : j'aimerais savoir comment les autres développeurs Go abordent les tests !

Avec ces bases, vous êtes sur la bonne voie pour écrire des tests solides qui rendent votre API Go plus fiable. Pour plus de conseils de test et de techniques avancées, restez à l’écoute des prochains articles. Bons tests ! ?