Go Academy · Leçon

Essais pilotés par table

Essais paramétrés avec des sous-essais

Essais pilotés par table est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Que sont les essais fondés sur des tableaux ?

Les essais fondés sur des tableaux définissent une tranche de cas d’essai (entrées et sorties attendues), puis la parcourent avec un seul corps d’essai. Ils réduisent la duplication et rendent l’ajout de cas trivial.

Modèle de base

Définissez une structure pour chaque cas, parcourez-la avec t.Run et signalez les échecs avec le nom du cas :

tests := []struct {
    name  string
    input int
    want  int
}{
    {"zero", 0, 0},
    {"positive", 3, 9},
    {"negative", -2, 4},
}
for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        got := Square(tt.input)
        if got != tt.want {
            t.Errorf("Square(%d) = %d; want %d", tt.input, got, tt.want)
        }
    })
}

Tranche de structures anonymes

Utilisez une structure anonyme pour le type de cas d’essai : cela maintient la définition du cas près de l’essai et évite de nommer un type utilisé une seule fois.

Inclure les cas d’erreur

Ajoutez un champ wantErr bool pour vérifier que les fonctions renvoient des erreurs dans les situations attendues :

{"invalid input", -1, 0, true},
// in the loop:
if (err != nil) != tt.wantErr {
    t.Errorf("wantErr %v, got err %v", tt.wantErr, err)
}

Nommer les sous-essais

Un champ de nom descriptif rend les échecs explicites. Vous pouvez exécuter un cas précis avec -run TestFunc/case_name.

Sous-essais parallèles avec t.Run

Marquez chaque sous-essai comme parallèle et capturez la variable de boucle pour exécuter les cas simultanément (ce qui est important lorsque les essais sont limités par les entrées-sorties).

for _, tt := range tests {
    tt := tt // capture
    t.Run(tt.name, func(t *testing.T) {
        t.Parallel()
        // ...
    })
}

Préparation partagée par cas

Utilisez des champs de fonction tt.setup pour permettre une préparation propre à chaque cas sans dupliquer le code répétitif :

type tc struct {
    setup func() *DB
    input string
    want  int
}

Garder les cas lisibles

Si les cas deviennent volumineux, définissez-les comme variables nommées ou chargez-les depuis des fichiers de données d’essai. Gardez le tableau compact : une ligne par cas dans la mesure du possible.

Tester plusieurs sorties

Organisez dans un tableau les fonctions d’essai qui renvoient plusieurs valeurs en ajoutant un champ par sortie :

type tc struct {
    input     string
    wantVal   int
    wantErr   bool
}

Assertions testify dans les tableaux

Utilisez github.com/stretchr/testify/assert dans les essais fondés sur des tableaux pour obtenir des assertions lisibles sans blocs if/t.Errorf verbeux.

assert.Equal(t, tt.want, got, tt.name)

Documenter avec des cas

Le tableau des cas sert de documentation vivante. Les futurs développeurs peuvent le lire pour comprendre d’un coup d’œil toutes les entrées prises en charge et les cas limites.

Vérification rapide

Pourquoi capturez-vous la variable de boucle (tt := tt) avant t.Parallel dans les essais fondés sur des tableaux ?

Récapitulatif : essais fondés sur des tableaux

Points clés :

Tranche de structures couvrant les entrées, les sorties attendues et l’indicateur d’erreur
Parcours avec t.Run pour obtenir des sous-essais nommés et indépendants
Capture de la variable de boucle (tt := tt) avant t.Parallel
Les cas servent de documentation vivante des comportements pris en charge

Questions Fréquemment Posées

La leçon « Essais pilotés par table » est-elle gratuite ?

Oui — le texte complet de « Essais pilotés par table » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Essais pilotés par table » ?

Essais paramétrés avec des sous-essais Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Essais pilotés par table » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Écrire des essais unitaires avec testing
Essais pilotés par table
Doublures d’essai : mocks et stubs
Couverture des essais et testify

← Retour à Go Academy