Comment puis-je tester la configuration en utilisant le package de test dans Go?

Comment puis-je effectuer un traitement de configuration de test global qui ouvre la voie à tous les tests lors de l’utilisation du package de test ?

Comme exemple dans Nunit, il y a un atsortingbut [SetUp] .

 [TestFixture] public class SuccessTests { [SetUp] public void Init() { /* Load test data */ } } 

À partir de Go 1.4, vous pouvez implémenter la configuration / le déassembly (inutile de copier vos fonctions avant / après chaque test). La documentation est décrite ici dans la section principale :

TestMain s’exécute dans la firebase database principale et peut effectuer la configuration et le déassembly nécessaires autour d’un appel à m.Run. Il faut alors appeler os.Exit avec le résultat de m.Run

Il m’a fallu du temps pour comprendre que si un test contenait une fonction de test func TestMain(m *testing.M) cette fonction serait appelée au lieu de lancer le test. Et dans cette fonction, je peux définir comment les tests vont fonctionner. Par exemple, je peux implémenter la configuration globale et le déassembly:

 func TestMain(m *testing.M) { mySetupFunction() retCode := m.Run() myTeardownFunction() os.Exit(retCode) } 

Quelques autres exemples peuvent être trouvés ici .

Cela peut être réalisé en plaçant une fonction init() dans le fichier _test.go . Cela sera exécuté avant la fonction init() .

 // package_test.go package main func init() { /* load test data */ } 

Le fichier _test.init () sera appelé avant la fonction package init ().

En règle générale, les tests in go ne sont pas écrits dans le même style que les autres langages. Souvent, il y a relativement moins de fonctions de test, mais chacune contient un ensemble de cas de test piloté par une table. Voir cet article écrit par l’une des équipes de Go.

Avec un test basé sur une table, vous placez simplement un code de configuration avant la boucle qui exécute les cas de test individuels spécifiés dans la table, et vous mettez ensuite tout code de nettoyage.

Si vous avez toujours un code de configuration partagé entre les fonctions de test, vous pouvez extraire le code de configuration partagé dans une fonction et utiliser sync.Once s’il est important de l’exécuter une seule fois (ou comme le suggère une autre réponse, utilisez init() . a l’inconvénient que l’installation sera effectuée même si les go test -run ne sont pas exécutés (peut-être parce que vous avez limité les cas de test en utilisant go test -run ).

Je dirais que si vous pensez avoir besoin d’une configuration partagée entre différents tests qui s’exécute exactement une fois que vous en avez vraiment besoin, et si un test basé sur une table ne serait pas meilleur.

Étant donné une fonction simple au test unitaire:

 package math func Sum(a, b int) int { return a + b } 

Vous pouvez le tester avec une fonction de configuration qui renvoie la fonction de suppression. Et après avoir appelé setup (), vous pouvez faire un appel différé à la suppression ().

 package math import "testing" func setupTestCase(t *testing.T) func(t *testing.T) { t.Log("setup test case") return func(t *testing.T) { t.Log("teardown test case") } } func setupSubTest(t *testing.T) func(t *testing.T) { t.Log("setup sub test") return func(t *testing.T) { t.Log("teardown sub test") } } func TestAddition(t *testing.T) { cases := []struct { name ssortingng a int b int expected int }{ {"add", 2, 2, 4}, {"minus", 0, -2, -2}, {"zero", 0, 0, 0}, } teardownTestCase := setupTestCase(t) defer teardownTestCase(t) for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { teardownSubTest := setupSubTest(t) defer teardownSubTest(t) result := Sum(tc.a, tc.b) if result != tc.expected { t.Fatalf("expected sum %v, but got %v", tc.expected, result) } }) } } 

Go outil de test rapportera les instructions de journalisation dans la console shell:

 % go test -v === RUN TestAddition === RUN TestAddition/add === RUN TestAddition/minus === RUN TestAddition/zero --- PASS: TestAddition (0.00s) math_test.go:6: setup test case --- PASS: TestAddition/add (0.00s) math_test.go:13: setup sub test math_test.go:15: teardown sub test --- PASS: TestAddition/minus (0.00s) math_test.go:13: setup sub test math_test.go:15: teardown sub test --- PASS: TestAddition/zero (0.00s) math_test.go:13: setup sub test math_test.go:15: teardown sub test math_test.go:8: teardown test case PASS ok github.com/kare/go-unit-test-setup-teardown 0.010s % 

Vous pouvez transmettre certains parameters supplémentaires à la configuration / à la suppression avec cette approche.

Le framework de test Go n’a rien d’équivalent à l’ atsortingbut SetUp de NUnit (marquant une fonction à appeler avant chaque test de la suite). Il y a cependant quelques options:

  1. Appelez simplement votre fonction SetUp partir de chaque test où il est nécessaire.

  2. Utilisez une extension du framework de test de Go qui implémente les paradigmes et les concepts de xUnit. Trois options fortes viennent à l’esprit:

    • va vérifier
    • témoigner
    • unité G

Chacune de ces bibliothèques vous encourage à organiser vos tests dans des suites / fixtures similaires aux autres frameworks xUnit, et appellera les méthodes d’installation sur le type suite / fixture avant chacune des méthodes Test* .