Qu'est-ce que les tests unitaires ?
La première étape consiste à comprendre ce tests unitaires moyens. Tests unitaires fait référence au processus de test de petites unités de code ou de modules pour s'assurer que chacun d'eux fonctionne comme prévu. Tests unitaires est utilisé pour supprimer les problèmes du code, améliorer la stabilité du code et garantir l'exactitude lors de la mise à jour du code. La première étape du test logiciel est la Test de l'unité , suivi du test d'interface utilisateur et du test d'intégration.
Le pack de test
à Golang, tests unitaires est effectué à l'aide d'un package appelé essai . Le package fournit diverses fonctions qui nous permettent de tester notre code. Le code Go peut être testé automatiquement à l'aide du package de test.
Exemple de programme à tester
Nous avons besoin de code pour nos tests à analyser avant de pouvoir écrire tests unitaires . Nous allons créer un petit programme qui additionne deux nombres.
paquet principal
importer (
'fmt'
)
fonctionAjouter ( un entier , b entier ) entier {
retour un + b
}
fonction principale ( ) {
fmt. Imprimerln ( Ajouter ( 2 , 3 ) )
}
Le code ci-dessus définit le Ajouter() fonction, qui additionne deux nombres, un et b , comme entrées et sorties le résultat sous forme d'entier. Ajouter les nombres 2 et 3 est tout ce que fait la fonction principale avant d'imprimer le résultat.
Convention d'écriture des tests unitaires dans le Go
Chaque projet Go doit avoir un fichier de test séparé contenant tous les tests de ce projet. Le fichier doit avoir le même nom que le fichier testé et doit avoir _test.go ajouté à la fin du nom de fichier. Par exemple, si nous voulons tester un fichier nommé calculatrice.go , nous devrions nommer notre fichier de test calculateur_test.go .
C'est une pratique courante pour Aller tester les fichiers être situé dans le même package ou répertoire que le code qu'ils évaluent. Lorsque vous utilisez la commande go build, le compilateur ne crée pas ces fichiers, vous n'avez donc pas à vous soucier de leur apparition dans les déploiements.
Pour écrire un Test de l'unité en Go, nous devons utiliser le essai emballer. Nous pouvons commencer chaque fonction de test avec le mot Test puis ajoutez une description de ce que nous voulons tester. Par exemple, TestAddition ou TestSoustraction . Nous pouvons ensuite écrire le code de test qui vérifie si la fonction que nous testons renvoie les résultats attendus.
Dans Go, chaque fonction de test doit commencer par l'instruction t := test.T{}. Cette déclaration crée un nouveau essai objet que nous pouvons utiliser pour vérifier si le test a réussi ou échoué. On peut alors utiliser le t.Erreurf() fonction pour imprimer un message d'erreur si le test échoue.
Comment écrire le code de test ?
Lorsqu'il s'agit d'écrire des tests unitaires en Go, il est important de commencer par spécifier le package que vous souhaitez tester. Après avoir importé le package de test, vous pouvez accéder à divers types et méthodes que le package exporte, y compris le test.T taper. La logique de test elle-même est ensuite écrite dans une fonction qui commence par le mot-clé 'Test' suivi d'un nom descriptif, tel que TestAjouter() . Dans cette fonction, vous pouvez inclure le code du test et toutes les assertions nécessaires pour vérifier le comportement attendu.
Pour résumer, les caractéristiques d'un test en Go sont les suivantes :
- Le seul et unique paramètre obligatoire est t *test.T
- La fonction de test commence par le mot Test et est ensuite suivie d'un mot ou d'une phrase commençant par une majuscule.
- Pour indiquer un échec, la fonction de test doit appeler soit t.Erreurf ou t. Échec, et pour fournir des informations de débogage supplémentaires sans provoquer d'échec, t.Log peut être utilisé.
- Pour fournir des informations de débogage sans faille, utilisez t.Log.
- Les tests sont stockés dans des fichiers portant le nom foo_test.go , Par exemple, math_test.go .
Fermez le fichier après l'avoir enregistré.
paquet principalimporter (
'essai'
)
fonctionTestAjouter ( t * essai. J ) {
résultat := Ajouter ( 2 , 3 )
si résultat != 5 {
t. Erreurf ( 'Add(2, 3) = %d; veux 5' , résultat )
}
}
Le Ajouter() fonction est testée par le TestAjouter() fonction définie dans ce test. Il utilise les nombres 2 et 3 pour appeler Add, puis il confirme que le résultat est 5. Un message d'erreur est imprimé si le résultat est inférieur à 5 lorsque t.Erreurf() est invoqué.
Enfin, il est important de savoir que Go dispose d'un outil de test intégré appelé allez tester. Cet outil exécute tous les tests du projet et fournit un rapport des résultats. Allez tester doit être tapé dans le terminal dans le répertoire du projet pour démarrer les tests. Tous les tests de ce répertoire seront exécutés en conséquence.
< fort > aller tester < test - déposer - nom > _test. aller fort > 
Résultats du test unitaire
La sortie vous montrera les fonctions de test qui ont réussi, échoué ou ignoré.
PASS ou OK indique que le code fonctionne comme prévu. Vous allez recevoir ÉCHOUER si un test échoue.
Le _test.go suffixe est le seul que la sous-commande go test vérifie dans les fichiers. Ensuite, go test recherche dans ces fichiers toutes les fonctions spéciales, telles que func TestXxx et plusieurs autres. Go test construit et appelle ces fonctions correctement, les exécute, rassemble et rapporte les résultats, et enfin nettoie tout dans un package principal temporaire.
La dernière étape consiste à intégrer vos tests dans votre workflow de développement. La meilleure pratique consiste à exécuter vos tests chaque fois que vous validez votre code dans un référentiel. L'intégration de vos tests dans votre workflow de développement garantit que votre code est testé en permanence et que tous les problèmes sont résolus avant le déploiement.
Conclusion
En écrivant tests unitaires est un élément crucial du développement logiciel car il garantit que votre code est évolutif, fonctionnel et efficace. La bibliothèque de tests Go est facile et simple à utiliser. Vous devriez pouvoir créer Golang tests unitaires de la plus haute qualité en suivant les procédures énumérées ci-dessus. N'oubliez pas d'intégrer vos tests dans votre workflow de développement pour vous assurer que votre code est testé en permanence et que tous les problèmes sont résolus avant le déploiement.