unittest

Le test doit faire partie du processus de développement, et on devrait même écrire les tests avant même de développer le code. Pour utiliser le module de test sous python : import unittest

Principes de fonctionnement des tests :

on crée une classe qui dérive de unittest.TestCase et qui a des méthodes test* (le nom doit commencer par test) et qui doivent terminer par une assertion qui doit être exacte.
a chaque test lancé (appel d'une méthode test*), la méthode setUp est appelée avant pour mettre en place des données avant le test, et la méthode tearDown est appelée après pour faire le ménage.
donc, il faut implémenter : les différentes méthodes test*, la méthode setUp et la méthode tearDown.

exemple :

def myDivision(a, b):
    return a / b

class MyTests(unittest.TestCase):
    def setUp(self):
        self.values = [4, 3, 2, 1]

    def testMax(self):
        self.assertEqual(max(self.values), 4)

    def testMin(self):
        self.assertTrue(min(self.values) == 1)

    def testDivisionByZero(self):
        self.assertRaises(ZeroDivisionError, myDivision, 1, 0)

    def tearDown(self):
        sys.stderr.write('called tearDown\n')

on exécute les différents tests par : unittest.main().

Différents types d'assertions :

assertTrue(self, expr) : vérifie si l'expression est vraie.
assertFalse(self, expr) : vérifie si l'expression est fausse.
assertEqual(self, val1, val2) : vérifie si les 2 arguments sont égaux (il y a aussi assertNotEqual).
assertAlmostEqual(self, val1, val2) : vérifie si les 2 arguments sont bien quasi identiques, à la 7ème décimale près par défaut (il y a aussi assertAlmostNotEqual).
assertGreater(self, val1, val2) : vérifie si val1 > val2 (idem avec assertLess).
assertGreaterEqual(self, val1, val2) : vérifie si val1 >= val2 (idem avec assertLessEqual).
assertDictEqual(self, dict1, dict2) : vérifie si les 2 dictionnaires sont identiques.
assertListEqual(self, l1, l2) : vérifie si les 2 listes sont identiques.
assertSetEqual(self, s1, s2) : vérifie si les 2 sets sont identiques.
assertTupleEqual(self, t1, t2) : vérifie si les 2 tuples sont identiques.
assertIn(self, val, obj) : vérifie si val in obj (il y a aussi assertNotIn).
assertIsNone(self, val) : vérifie si val vaut None (il y a aussi assertIsNotNone)
assertRaises(self, myException, myFunction, arg1, arg2, ...) : appelle myFunction avec les arguments donnés après (arg1, arg2, ...) et vérifie que ca lance bien une exception de type myException (cf exemple ci-dessus).

Toutes ces assertions peuvent prendre un argument msg qui est le message à sortir en cas d'erreur (plus explicite) : self.assertTrue(1 == 2, msg = '1 ne vaut pas 2')

On peut faire exécuter du code avant tous les tests et après tous les tests grâce à 2 méthodes de classe :

méthode appelée avant tous les tests :

    @classmethod
    def setUpClass():
        sys.stderr.write('First initialization\n')

méthode appelée après tous les tests :

    @classmethod
    def tearDownClass():
        sys.stderr.write('First initialization\n')

Pour exécuter le code de test contenu à l'intérieur d'un module myModule : python -m unittest myModule

programmer en python, tutoriel python, graphes en python, Aymeric Duclert