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 :
Pour exécuter le code de test contenu à l'intérieur d'un module myModule : python -m unittest myModule
