Framework UnitTest - API

Ce chapitre traite des classes et méthodes définies dans le module unittest. Il y a cinq classes principales dans ce module.

Classe TestCase

L'objet de cette classe représente la plus petite unité testable. Il contient les routines de test et fournit des crochets pour préparer chaque routine et pour le nettoyage par la suite.

Les méthodes suivantes sont définies dans la classe TestCase -

Sr.No.	Méthode et description
1	setUp() Méthode appelée pour préparer le montage d'essai. Ceci est appelé immédiatement avant d'appeler la méthode de test
2	tearDown() Méthode appelée immédiatement après l'appel de la méthode de test et le résultat enregistré. Ceci est appelé même si la méthode de test a déclenché une exception,
3	setUpClass() Une méthode de classe appelée avant les tests dans une classe individuelle.
4	tearDownClass() Une méthode de classe appelée après l'exécution des tests dans une classe individuelle.
5	run(result = None) Exécutez le test en collectant le résultat dans l'objet de résultat du test transmis comme résultat .
6	skipTest(reason) L'appeler pendant une méthode de test ou setUp () ignore le test en cours.
sept	debug() Exécutez le test sans collecter le résultat.
8	shortDescription() Renvoie une description en une ligne du test.

Agencements

Il peut y avoir de nombreux tests écrits dans une classe TestCase. Ces méthodes de test peuvent nécessiter une connexion à la base de données, des fichiers temporaires ou d'autres ressources pour être initialisées. Celles-ci sont appelées luminaires. TestCase comprend un crochet spécial pour configurer et nettoyer tous les appareils nécessaires à vos tests. Pour configurer les appareils, remplacez setUp (). Pour nettoyer, remplacez tearDown ().

Dans l'exemple suivant, deux tests sont écrits dans la classe TestCase. Ils testent le résultat de l'addition et de la soustraction de deux valeurs. La méthode setup () initialise les arguments en fonction de shortDescription () de chaque test. La méthode teardown () sera exécutée à la fin de chaque test.

import unittest

class simpleTest2(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      if name == "Add":
         self.a = 10
         self.b = 20
         print name, self.a, self.b
      if name == "sub":
         self.a = 50
         self.b = 60
         print name, self.a, self.b
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
if __name__ == '__main__':
   unittest.main()

Exécutez le code ci-dessus à partir de la ligne de commande. Il donne la sortie suivante -

C:\Python27>python test2.py
Add 10 20
F
end of test Add
sub 50 60
end of test sub
.
================================================================
FAIL: testadd (__main__.simpleTest2)
Add
----------------------------------------------------------------------
Traceback (most recent call last):
   File "test2.py", line 21, in testadd
      self.assertTrue(result == 100)
AssertionError: False is not true
----------------------------------------------------------------------
Ran 2 tests in 0.015s

FAILED (failures = 1)

Appareil de classe

La classe TestCase a une méthode setUpClass () qui peut être remplacée pour s'exécuter avant l'exécution de tests individuels dans une classe TestCase. De même, la méthode tearDownClass () sera exécutée après tous les tests de la classe. Les deux méthodes sont des méthodes de classe. Par conséquent, ils doivent être décorés avec la directive @classmethod.

L'exemple suivant illustre l'utilisation de ces méthodes de classe -

import unittest

class TestFixtures(unittest.TestCase):

   @classmethod
   def setUpClass(cls):
      print 'called once before any tests in class'

   @classmethod
   def tearDownClass(cls):
      print '\ncalled once after all tests in class'

   def setUp(self):
      self.a = 10
      self.b = 20
      name = self.shortDescription()
      print '\n',name
   def tearDown(self):
      print '\nend of test',self.shortDescription()

   def test1(self):
      """One"""
      result = self.a+self.b
      self.assertTrue(True)
   def test2(self):
      """Two"""
      result = self.a-self.b
      self.assertTrue(False)
      
if __name__ == '__main__':
unittest.main()

Classe TestSuite

Le cadre de test de Python fournit un mécanisme utile par lequel les instances de cas de test peuvent être regroupées en fonction des fonctionnalités qu'elles testent. Ce mécanisme est rendu disponible par la classe TestSuite dans le module unittest.

Les étapes suivantes sont impliquées dans la création et l'exécution d'une suite de tests.

Step 1 - Créez une instance de la classe TestSuite.

suite = unittest.TestSuite()

Step 2 - Ajoutez des tests dans une classe TestCase dans la suite.

suite.addTest(testcase class)

Step 3 - Vous pouvez également utiliser la méthode makeSuite () pour ajouter des tests à partir d'une classe

suite = unittest.makeSuite(test case class)

Step 4 - Des tests individuels peuvent également être ajoutés dans la suite.

suite.addTest(testcaseclass(""testmethod")

Step 5 - Créez un objet de la classe TestTestRunner.

runner = unittest.TextTestRunner()

Step 6 - Appelez la méthode run () pour exécuter tous les tests de la suite

runner.run (suite)

Les méthodes suivantes sont définies dans la classe TestSuite -

Sr.No.	Méthode et description
1	addTest() Ajoute une méthode de test dans la suite de tests.
2	addTests() Ajoute des tests à partir de plusieurs classes TestCase.
3	run() Exécute les tests associés à cette suite, en collectant le résultat dans l'objet de résultat de test
4	debug() Exécute les tests associés à cette suite sans collecter le résultat.
5	countTestCases() Renvoie le nombre de tests représentés par cet objet de test

L'exemple suivant montre comment utiliser la classe TestSuite -

import unittest
class suiteTest(unittest.TestCase):
   def setUp(self):
      self.a = 10
      self.b = 20
      
   def testadd(self):
      """Add"""
      result = self.a+self.b
      self.assertTrue(result == 100)
   def testsub(self):
      """sub"""
      result = self.a-self.b
      self.assertTrue(result == -10)
      
def suite():
   suite = unittest.TestSuite()
##   suite.addTest (simpleTest3("testadd"))
##   suite.addTest (simpleTest3("testsub"))
   suite.addTest(unittest.makeSuite(simpleTest3))
   return suite
   
if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   runner.run (test_suite)

Vous pouvez expérimenter la méthode addTest () en décommentant les lignes et l'instruction de commentaire ayant la méthode makeSuite ().

Classe TestLoader

Le package unittest a la classe TestLoader qui est utilisée pour créer des suites de tests à partir de classes et de modules. Par défaut, l'instance unittest.defaultTestLoader est automatiquement créée lorsque la méthode unittest.main (0 est appelée. Une instance explicite permet cependant la personnalisation de certaines propriétés.

Dans le code suivant, les tests de deux classes sont collectés dans une liste à l'aide de l'objet TestLoader.

import unittest
testList = [Test1, Test2]
testLoad = unittest.TestLoader()

TestList = []
for testCase in testList:
   testSuite = testLoad.loadTestsFromTestCase(testCase)
   TestList.append(testSuite)
   
newSuite = unittest.TestSuite(TestList)
runner = unittest.TextTestRunner()
runner.run(newSuite)

Le tableau suivant présente une liste des méthodes de la classe TestLoader -

Sr.Non	Méthode et description
1	loadTestsFromTestCase() Renvoie une suite de tous les cas de tests contenus dans une classe TestCase
2	loadTestsFromModule() Renvoie une suite de tous les cas de tests contenus dans le module donné.
3	loadTestsFromName() Renvoie une suite de tous les cas de test avec un spécificateur de chaîne.
4	discover() Trouvez tous les modules de test en récursant dans les sous-répertoires à partir du répertoire de démarrage spécifié et retournez un objet TestSuite

Classe TestResult

Cette classe est utilisée pour compiler des informations sur les tests qui ont réussi et les tests qui ont échoué. Un objet TestResult stocke les résultats d'un ensemble de tests. Une instance TestResult est retournée par la méthode TestRunner.run ().

Les instances TestResult ont les attributs suivants -

Sr.No.	Attribut et description
1	Errors Une liste contenant 2-tuples d'instances et de chaînes TestCase contenant des traces formatées. Chaque tuple représente un test qui a déclenché une exception inattendue.
2	Failures Une liste contenant 2-tuples d'instances et de chaînes TestCase contenant des traces formatées. Chaque tuple représente un test où un échec a été signalé explicitement à l'aide des méthodes TestCase.assert * ().
3	Skipped Une liste contenant 2-tuples d'instances et de chaînes TestCase contenant la raison pour laquelle le test a été ignoré.
4	wasSuccessful() Renvoie True si tous les tests exécutés jusqu'à présent ont réussi, sinon renvoie False.
5	stop() Cette méthode peut être appelée pour signaler que l'ensemble de tests en cours d'exécution doit être abandonné.
6	startTestRun() Appelé une fois avant l'exécution des tests.
sept	stopTestRun() Appelé une fois après l'exécution de tous les tests.
8	testsRun Le nombre total de tests exécutés jusqu'à présent.
9	Buffer Si défini sur true, sys.stdout et sys.stderrsera mis en mémoire tampon entre les appels de startTest () et stopTest () .

Le code suivant exécute une suite de tests -

if __name__ == '__main__':
   runner = unittest.TextTestRunner()
   test_suite = suite()
   result = runner.run (test_suite)
   
   print "---- START OF TEST RESULTS"
   print result

   print "result::errors"
   print result.errors

   print "result::failures"
   print result.failures

   print "result::skipped"
   print result.skipped

   print "result::successful"
   print result.wasSuccessful()
   
   print "result::test-run"
   print result.testsRun
   print "---- END OF TEST RESULTS"

Le code lorsqu'il est exécuté affiche la sortie suivante -

---- START OF TEST RESULTS
<unittest.runner.TextTestResult run = 2 errors = 0 failures = 1>
result::errors
[]
result::failures
[(<__main__.suiteTest testMethod = testadd>, 'Traceback (most recent call last):\n
   File "test3.py", line 10, in testadd\n 
   self.assertTrue(result == 100)\nAssert
   ionError: False is not true\n')]
result::skipped
[]
result::successful
False
result::test-run
2
---- END OF TEST RESULTS