Phenquestions
Les tests unitaires sont une méthode de test utilisée en génie logiciel pour les unités individuelles de n'importe quel code. Les utilisateurs peuvent mettre les tests individuels pour déterminer l'état de la source et dans quelle mesure le code peut être utilisé. De cette façon, les utilisateurs peuvent tester la qualité du code.
Les tests sont effectués une fois le processus de développement terminé. Les utilisateurs peuvent également commencer les tests lorsque le script de test doit être vérifié en fonction des critères du test. Les développeurs sont censés écrire les types manuels du code source. En règle générale, l'écriture manuelle de codes de test unitaire est une tâche mouvementée, mais en Python, elle est effectuée à l'aide d'une fonction intégrée appelée unittest.
Test de l'unité
Les tests en Python sont effectués par le framework unittest. Les tests unitaires rendent le code sécurisé et facile à utiliser à l'avenir également. Les utilisateurs ne peuvent généralement pas prédire ces cas, mais peuvent facilement les traiter. Unittest peut être soit le module entier, une fonction particulière et une interface entière (classe/module).
Comment écrire des tests unitaires pour votre code?
Pour écrire les tests unitaires de votre code, commencez toujours par la plus petite unité pouvant être testée à partir de l'ensemble de votre code, puis passez à d'autres unités. De cette façon, vous vérifierez comment la plus petite unité choisie interagit pour construire un test unitaire complet.
Le framework de tests unitaires de Python a été formé en prenant en compte le Junit de Java. Il a les mêmes fonctionnalités que les tests unitaires sont effectués dans d'autres types de langues. Le cadre des tests unitaires en Python facilite les tests d'automatisation, la configuration du partage, l'agrégation de nombreux tests en un seul grand ensemble et des tests indépendants
Exemples:
Maintenant, dans l'exemple, nous vérifions le code pour trouver la somme dans le code Python à l'aide de la fonction sum(). La réponse à cette somme doit être 12, ce qui est correct.
>>> assert sum([2, 4, 6]) == 12, "devrait être égal à 12"
D'un autre côté, si nous essayons d'écrire une valeur de sortie erronée, dont la somme () est incorrecte, les résultats échoueront. Il renverra une AssertionError. La sortie que nous avons indiquée est fausse, c'est-à-dire 12, et la sortie réelle doit être 6, elle a donc renvoyé cette erreur.
>>> assert sum([2, 2, 2]) == 12, "devrait être égal à 12"
Maintenant, au lieu de tester sur le REPL, nous allons mettre un nouveau fichier Python et le nommer somme_test.py
>> def testValue_sum() :assert sum([2, 4, 6]) == 12, "devrait être égal à 12"
if __name__ == "__main__":
testValue_sum()
print("Tout a été passé correctement")
Après avoir écrit le scénario de test, vous pouvez accéder au répertoire qui a le test_sum.py, puis tapez :
$ somme_test python.pyProduction:
La valeur de sortie, lorsqu'elle est similaire à celle affichée, approuvera la valeur correcte.
Créons un autre fichier pour .py tester la somme. L'exemple tel qu'il est affiché dans le code et peut être utilisé comme exemple en copiant :
def testValue_sum() :assert sum([2, 4, 6]) == 12, "devrait être égal à 12"
def testValue_sum_tuple() :
assert sum((1, 1, 1)) == 6, "devrait être égal à 6"
if __name__ == "__main__":
testValue_sum()
testValue_sum_tuple()
print("Tout a été passé correctement")
Cette fois, nous allons à nouveau nommer le fichier somme_test.py
Le premier bloc de code est correct, tandis que le deuxième bloc de code est faux et comporte une erreur, donc notre sortie renverra le même.
Maintenant, nous allons retourner dans le répertoire du projet, où nous avons enregistré le .fichier py, puis testez le fichier à l'aide de la commande suivante :
$ somme_test python.py
Production:
Cette fois, puisque le code d'entrée a eu une erreur, il devrait renvoyer l'erreur d'assertion en réponse.
Exemple d'utilisation de unittest :
Les exigences Unittest sont que les utilisateurs peuvent placer leurs tests dans des classes en tant que méthodes différentes, les utilisateurs peuvent utiliser une série de méthodes d'assertion et la classe TestCase peut être utilisée à la place de l'instruction assert.
Les utilisateurs peuvent convertir l'exemple discuté dans la moitié précédente en un cas de test unitaire.
Tout d'abord, importez la bibliothèque unitest. Ensuite, vous devez créer un TestSum à partir de différentes classes.
Créez un nouveau fichier pour le code décrit ci-dessous :
test unitaire d'importationclasse TestSum(unittest.Cas de test):
def testValue_sum(self):
soi.assertEqual(sum([2, 4, 6]), 12, "Devrait être égal à 12")
def testValue_sum_tuple(self):
soi.assertEqual(sum((1, 1, 1)), 6, "Devrait être égal à 6")
if __name__ == '__main__' :
Test de l'unité.principale()
Une fois que vous avez exécuté cette commande, la sortie a un point. Cela signifie le succès et un F signifie un échec.
Donc, nous avons du succès et un autre est un échec.
Production:
Rédaction du premier test :
Créez un nouveau dossier de projet puis créez un nouveau dossier, nous l'appellerons sum_file. À l'intérieur, créez un fichier et nommez-le, __init__.py. Faites le dossier du projet comme celui-ci :
projet/│
└── sum_file/
└── __init__.py
Ensuite, vous devez ouvrir my_sum/__init__.py et créez une nouvelle fonction sum(). Il sera itérable (une liste, un tuple ou un ensemble) d'ajouter de nombreuses valeurs :
def sum(arg):total_ValueCalculated = 0
pour val dans arg :
total_ValueCalculated += val
return total_ValueCalculated
Ensuite, vous devez créer un test déposer. Commencez par écrire des tests et créez un fichier de test appelé testFichier.py. Pour importer l'application, et elle doit être testée, placez le fichier testFichier.py au dessus de votre dossier du colis. Ce qui suit sera l'aspect général de votre répertoire :
projet/│
├── sum_file/
│ └── __init__.py
|
└── fichier test.py
Comme indiqué précédemment pour tester le code, vous pouvez utiliser la commande suivante dans la fenêtre du terminal/la ligne de commande :
$ python -m test unitaireConclusion
L'article traite du processus de test unitaire en Python. Le test est l'une des fonctionnalités utiles de l'ingénierie logicielle qui est capable de diviser les codes en morceaux plus petits, puis de les essayer un par un. Les utilisateurs peuvent également compiler l'ensemble des échantillons de test/codes unitaires en une seule grande collection. Unittest est une fonction utilisée dans Python pour faciliter l'utilisation des tests.
