Tests et benchmarks

Le package testing

Go a le testing intégré dans le langage. Pas besoin d'installer Jest, pytest ou PHPUnit. Tout est déjà là.

Règles simples :

• Le fichier de test s'appelle *_test.go (ex : math_test.go)
• Les fonctions de test commencent par Test (majuscule)
• Elles prennent un paramètre *testing.T

// math.go
package math

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

// math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d, attendu 5", result)
    }
}

Lancez les tests avec go test :

$ go test
PASS
ok      myproject/math  0.002s

0.002 secondes. Pas de setup, pas de configuration, pas de dépendances. Juste go test.

Table-driven tests : l'idiome Go

Les table-driven tests sont le pattern le plus utilisé en Go. Au lieu d'écrire une fonction par cas de test, vous définissez un tableau de cas :

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positifs", 2, 3, 5},
        {"négatifs", -1, -2, -3},
        {"zéro", 0, 0, 0},
        {"mixte", -5, 10, 5},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d, attendu %d",
                    tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

Chaque cas de test a un nom : quand un test échoue, vous savez immédiatement lequel. Et ajouter un nouveau cas ? Une seule ligne.

=== RUN   TestAdd
=== RUN   TestAdd/positifs
=== RUN   TestAdd/négatifs
=== RUN   TestAdd/zéro
=== RUN   TestAdd/mixte
--- PASS: TestAdd (0.00s)
PASS

Benchmarks : mesurer les performances

Go intègre aussi les benchmarks. Même fichier _test.go, mais avec Benchmark au lieu de Test :

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

Lancez avec go test -bench=. :

$ go test -bench=.
BenchmarkAdd-8   1000000000   0.2850 ns/op
PASS

Go a exécuté la fonction 1 milliard de fois et chaque appel a pris 0.28 nanosecondes. C'est comme ça qu'on vérifie que le code est performant : avec des chiffres, pas des intuitions.

Vous pouvez aussi mesurer la mémoire avec -benchmem :

$ go test -bench=. -benchmem
BenchmarkAdd-8   1000000000   0.2850 ns/op   0 B/op   0 allocs/op

0 B/op : zéro allocation mémoire par opération. Voilà pourquoi Go est rapide.

Commandes utiles

# Lancer tous les tests
go test ./...

# Tests avec détails
go test -v ./...

# Couverture de code
go test -cover ./...

# Générer un rapport de couverture
go test -coverprofile=cover.out ./...
go tool cover -html=cover.out

# Benchmarks
go test -bench=. -benchmem ./...

go test ./... lance les tests dans tous les packages de votre projet. Le -cover vous montre quel pourcentage de votre code est couvert par les tests.

À vous d'essayer (les vrais tests tournent avec go test, mais voici la même logique en programme exécutable) :

package main

import "fmt"

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

func main() {
    cases := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positifs", 2, 3, 5},
        {"négatifs", -1, -2, -3},
        {"zéro", 0, 0, 0},
    }

    for _, tt := range cases {
        result := Add(tt.a, tt.b)
        if result == tt.expected {
            fmt.Printf("PASS %s: Add(%d, %d) = %d\n", tt.name, tt.a, tt.b, result)
        } else {
            fmt.Printf("FAIL %s: Add(%d, %d) = %d, attendu %d\n", tt.name, tt.a, tt.b, result, tt.expected)
        }
    }
}

Pour aller plus loin

Vous maîtrisez maintenant les fondamentaux de Go. Voici les sujets avancés à explorer ensuite :

• Interfaces : le polymorphisme en Go, sans héritage Tour of Go
• Generics : les types paramétrés, arrivés avec Go 1.18 Tutorial
• Modules : go.mod pour gérer les dépendances Tutorial
• Gin / Echo : frameworks web populaires pour les API Gin · Echo
• GORM : l'ORM le plus utilisé en Go gorm.io

Références complètes : Go.dev Documentation · A Tour of Go · Go by Example

Vous êtes un développeur polyvalent

Go est le langage de l'infrastructure moderne. Performant, simple, conçu pour le cloud. Avec HTML/CSS/JS pour le front, PHP ou Python pour le back, et Go pour les services haute performance, vous avez une palette complète de développeur polyvalent.

Vous n'êtes plus un débutant : vous êtes un développeur qui utilise l'IA comme un outil, pas comme une béquille.

En 6 leçons, vous avez appris les variables, les fonctions, la gestion d'erreurs, la concurrence, les API REST et les tests. Vous avez les bases pour construire des services rapides et fiables.

La suite ? Construisez quelque chose. Un CLI, une API, un microservice. Le meilleur apprentissage, c'est la pratique.