Qu’est-ce que les tests unitaires Python ? (exemples détaillés)

Dans l'article suivant, nous découvrirons ce qu'est le test unitaire en python. Découvrez les tests unitaires Python et le rôle que les tests unitaires Python peuvent jouer dans la programmation Python.

Tests unitaires

Les tests unitaires sont utilisés pour tester l'exactitude d'un module, d'une fonction ou d'un travail de classe.

Par exemple, pour la fonction abs(), nous pouvons écrire les cas de test suivants :

1 Entrez un nombre positif, tel que 1, 1,2, 0,99, et attendez la valeur de retour. être identique à l'entrée ;

2. Entrez des nombres négatifs, tels que -1, -1,2, -0,99, et attendez-vous à ce que la valeur de retour soit opposée à l'entrée ; . Entrez 0, attendez-vous à renvoyer 0 ;

4. Si vous entrez un type non numérique, tel que None, [], {}, attendez-vous à ce qu'une TypeError soit générée.

Mettez les cas de test ci-dessus dans un module de test, qui est un test unitaire complet.

Si le test unitaire réussit, cela signifie que la fonction que nous avons testée peut fonctionner normalement. Si le test unitaire échoue, soit il y a un bug dans la fonction, soit les conditions de test sont mal saisies. Bref, il faut le corriger pour que le test unitaire réussisse.

A quoi ça sert de réussir un test unitaire ? Si nous apportons des modifications au code de la fonction abs(), il nous suffit de réexécuter le test unitaire. S'il réussit, cela signifie que notre modification n'affectera pas le comportement d'origine de la fonction abs(). signifie que notre modification Si elle est incompatible avec le comportement d'origine, modifiez le code ou modifiez le test.

Le plus grand avantage de ce modèle de développement piloté par les tests est de garantir que le comportement d'un module de programme est conforme aux cas de test que nous concevons. En cas de modification ultérieure, il peut être grandement garanti que le comportement du module sera toujours correct.

Écrivons une classe Dict. Cette classe se comporte de la même manière que dict, mais est accessible via des attributs. Elle s'utilise comme suit :

Le code mydict.py est le suivant. suit :

 >>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1

Pour écrire des tests unitaires, nous devons introduire le module unittest fourni avec Python et écrire mydict_test.py comme suit :

class Dict(dict):
    def __init__(self, **kw):
        super().__init__(**kw)
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
    def __setattr__(self, key, value):
        self[key] = value

Lors de l'écriture de tests unitaires , nous devons écrire une classe de test , héritée de unittest.TestCase.

import unittest

from mydict import Dict
class TestDict(unittest.TestCase):
    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEqual(d.a, 1)
        self.assertEqual(d.b, 'test')
        self.assertTrue(isinstance(d, dict))
    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')
    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEqual(d['key'], 'value')
    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']
    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

Les méthodes qui commencent par test sont des méthodes de test. Les méthodes qui ne commencent pas par test ne sont pas considérées comme des méthodes de test et ne seront pas exécutées pendant le test.

Une méthode test_xxx() doit être écrite pour chaque type de test. Étant donné que unittest.TestCase fournit de nombreux jugements conditionnels intégrés, il nous suffit d'appeler ces méthodes pour déterminer si le résultat correspond à ce que nous attendons. L'assertion la plus couramment utilisée est assertEqual() :

Une autre assertion importante est de s'attendre à ce qu'une erreur d'un type spécifié soit générée. Par exemple, lors de l'accès à une clé inexistante via d['empty. '], l'assertion will KeyError est lancée :

self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等

Lors de l'accès à une clé inexistante via d.empty, nous nous attendons à lancer AttributeError :

with self.assertRaises(KeyError):
    value = d['empty']

with self.assertRaises(AttributeError):
    value = d.empty

Exécuter le test unitaire

Une fois les tests unitaires écrits, nous pouvons exécuter les tests unitaires. La façon la plus simple de l'exécuter est d'ajouter deux lignes de code à la fin de mydict_test.py :

if __name__ == '__main__':
    unittest.main()

这样就可以把mydict_test.py当做正常的python脚本运行：

$ python mydict_test.py

另一种方法是在命令行通过参数-m unittest直接运行单元测试：

$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s
OK

 这是推荐的做法，因为这样可以一次批量运行很多单元测试，并且，有很多工具可以自动来运行这些单元测试。

以上就是本篇文章所讲述的所有内容，这篇文章主要介绍了python单元测试的相关知识，希望你能借助资料从而理解上述所说的内容。希望我在这片文章所讲述的内容能够对你有所帮助，让你学习python更加轻松。

更多相关知识，请访问php中文网Python教程栏目。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!