Framework UnitTest - Assertion

Le framework de test Python utilise la fonction assert () intégrée de Python qui teste une condition particulière. Si l'assertion échoue, une AssertionError sera déclenchée. Le cadre de test identifiera alors le test comme un échec. Les autres exceptions sont traitées comme une erreur.

Les trois ensembles de fonctions d'assertion suivants sont définis dans le module unittest -

Assertions booléennes de base
Assertions comparatives
Assertions pour les collections

Les fonctions d'assert de base évaluent si le résultat d'une opération est True ou False. Toutes les méthodes d'assert acceptent unmsg argument qui, s'il est spécifié, est utilisé comme message d'erreur en cas d'échec.

Sr.No.	Méthode et description
1	assertEqual(arg1, arg2, msg = None) Testez que arg1 et arg2 sont égaux. Si les valeurs ne sont pas égales, le test échouera.
2	assertNotEqual(arg1, arg2, msg = None) Testez que arg1 et arg2 ne sont pas égaux. Si les valeurs se comparent égales, le test échouera.
3	assertTrue(expr, msg = None) Vérifiez que expr est vrai. Si faux, le test échoue
4	assertFalse(expr, msg = None) Vérifiez que expr est faux. Si vrai, le test échoue
5	assertIs(arg1, arg2, msg = None) Testez que arg1 et arg2 évaluent le même objet.
6	assertIsNot(arg1, arg2, msg = None) Testez que arg1 et arg2 ne correspondent pas au même objet.
sept	assertIsNone(expr, msg = None) Testez que expr est None. Si non Aucun, le test échoue
8	assertIsNotNone(expr, msg = None) Testez que expr n'est pas None. Si aucun, le test échoue
9	assertIn(arg1, arg2, msg = None) Testez que arg1 est dans arg2 .
dix	assertNotIn(arg1, arg2, msg = None) Testez que arg1 n'est pas dans arg2 .
11	assertIsInstance(obj, cls, msg = None) Tester que obj est une instance de cls
12	assertNotIsInstance(obj, cls, msg = None) Tester que obj n'est pas une instance de cls

Certaines des fonctions d'assertion ci-dessus sont implémentées dans le code suivant -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertEqual(4 + 5,9)
   def test2(self):
      self.assertNotEqual(5 * 2,10)
   def test3(self):
      self.assertTrue(4 + 5 == 9,"The result is False")
   def test4(self):
      self.assertTrue(4 + 5 == 10,"assertion fails")
   def test5(self):
      self.assertIn(3,[1,2,3])
   def test6(self):
      self.assertNotIn(3, range(5))

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

Lorsque le script ci-dessus est exécuté, test2, test4 et test6 afficheront un échec et les autres s'exécuteront avec succès.

FAIL: test2 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 9, in test2
      self.assertNotEqual(5*2,10)
AssertionError: 10 == 10

FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 13, in test4
      self.assertTrue(4+5==10,"assertion fails")
AssertionError: assertion fails

FAIL: test6 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "C:\Python27\SimpleTest.py", line 17, in test6
      self.assertNotIn(3, range(5))
AssertionError: 3 unexpectedly found in [0, 1, 2, 3, 4]

----------------------------------------------------------------------            
Ran 6 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 3)

Le deuxième ensemble de fonctions d'assertion est comparative asserts −

assertAlmostEqual (premier, deuxième, places = 7, msg = Aucun, delta = Aucun)

Vérifiez que première et seconde sont à peu près (ou pas environ) correspondant en calculant la différence, arrondi au nombre donné de décimales endroits (par défaut 7),
assertNotAlmostEqual (premier, deuxième, lieux, msg, delta)

Vérifiez que le premier et le second ne sont pas à peu près égaux en calculant la différence, en arrondissant au nombre donné de décimales (7 par défaut) et en comparant à zéro.

Dans les deux fonctions ci-dessus, si delta est fourni au lieu de places, la différence entre le premier et le second doit être inférieure ou égale à (ou supérieure à) delta.

Fournir à la fois delta et places déclenche une TypeError.
assertGreater (premier, deuxième, msg = Aucun)

Vérifiez que le premier est supérieur à la seconde en fonction du nom de la méthode. Sinon, le test échouera.
assertGreaterEqual (premier, deuxième, msg = Aucun)

Vérifiez que le premier est supérieur ou égal à second en fonction du nom de la méthode. Sinon, le test échouera
assertLess (premier, deuxième, msg = Aucun)

Vérifiez que le premier est inférieur à la seconde selon le nom de la méthode. Sinon, le test échouera
assertLessEqual (premier, deuxième, msg = Aucun)

Vérifiez que le premier est inférieur ou égal à second en fonction du nom de la méthode. Sinon, le test échouera.
assertRegexpMatches (texte, expression régulière, msg = Aucun)

Vérifiez qu'une recherche d'expression régulière correspond au texte. En cas d'échec, le message d'erreur inclura le motif et le texte. regexp peut être un objet d'expression régulière ou une chaîne contenant une expression régulière pouvant être utilisée parre.search().
assertNotRegexpMatches (texte, expression régulière, msg = Aucun)

Vérifie qu'une recherche par expression régulière ne correspond pas au texte . Échoue avec un message d'erreur incluant le modèle et la partie de texte qui correspond. regexp peut être un objet d'expression régulière ou une chaîne contenant une expression régulière pouvant être utilisée par re.search () .

Les fonctions d'assertion sont implémentées dans l'exemple suivant -

import unittest
import math
import re

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertAlmostEqual(22.0/7,3.14)
   def test2(self):
      self.assertNotAlmostEqual(10.0/3,3)
   def test3(self):
      self.assertGreater(math.pi,3)
   def test4(self):
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")

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

Le script ci-dessus signale test1 et test4 comme un échec. Dans le test 1, la division de 22/7 n'est pas comprise entre 7 décimales et 3,14. De même, puisque le deuxième argument correspond au texte du premier argument, test4 aboutit à AssertionError.

=====================================================FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 7, in test1
      self.assertAlmostEqual(22.0/7,3.14)
AssertionError: 3.142857142857143 != 3.14 within 7 places
================================================================
FAIL: test4 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 13, in test4
      self.assertNotRegexpMatches("Tutorials Point (I) Private Limited","Point")
AssertionError: Regexp matched: 'Point' matches 'Point' in 'Tutorials Point (I)
Private Limited'
----------------------------------------------------------------------

Ran 4 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)

Assert pour les collections

Cet ensemble de fonctions d'assert est destiné à être utilisé avec des types de données de collection en Python, tels que List, Tuple, Dictionary et Set.

Sr.No.	Méthode et description
1	assertListEqual (list1, list2, msg = None) Teste que deux listes sont égales. Sinon, un message d'erreur est construit qui montre uniquement les différences entre les deux.
2	assertTupleEqual (tuple1, tuple2, msg = None) Teste que deux tuples sont égaux. Sinon, un message d'erreur est construit qui montre uniquement les différences entre les deux.
3	assertSetEqual (set1, set2, msg = None) Teste que deux ensembles sont égaux. Sinon, un message d'erreur est construit qui répertorie les différences entre les ensembles.
4	assertDictEqual (expected, actual, msg = None) Vérifiez que deux dictionnaires sont égaux. Sinon, un message d'erreur est construit qui montre les différences dans les dictionnaires.

L'exemple suivant implémente les méthodes ci-dessus -

import unittest

class SimpleTest(unittest.TestCase):
   def test1(self):
      self.assertListEqual([2,3,4], [1,2,3,4,5])
   def test2(self):
      self.assertTupleEqual((1*2,2*2,3*2), (2,4,6))
   def test3(self):
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})

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

Dans l'exemple ci-dessus, test1 et test3 affichent AssertionError. Le message d'erreur affiche les différences entre les objets Liste et Dictionnaire.

FAIL: test1 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 5, in test1
      self.assertListEqual([2,3,4], [1,2,3,4,5])
AssertionError: Lists differ: [2, 3, 4] != [1, 2, 3, 4, 5]

First differing element 0:
2
1

Second list contains 2 additional elements.
First extra element 3:
4

- [2, 3, 4]
+ [1, 2, 3, 4, 5]
? +++       +++

FAIL: test3 (__main__.SimpleTest)
----------------------------------------------------------------------
Traceback (most recent call last):
   File "asserttest.py", line 9, in test3
      self.assertDictEqual({1:11,2:22},{3:33,2:22,1:11})
AssertionError: {1: 11, 2: 22} != {1: 11, 2: 22, 3: 33}
- {1: 11, 2: 22}
+ {1: 11, 2: 22, 3: 33}
?              +++++++
                                                                                  
----------------------------------------------------------------------            
Ran 3 tests in 0.001s                                                             
                                                                                  
FAILED (failures = 2)

↰ Previous page Next page ↱

Framework UnitTest - Assertion

Assert pour les collections

Didacticiel du Framework UnitTest