Marco UnitTest - API

Este capítulo discute las clases y métodos definidos en el módulo unittest. Hay cinco clases principales en este módulo.

Clase TestCase

El objeto de esta clase representa la unidad comprobable más pequeña. Contiene las rutinas de prueba y proporciona ganchos para preparar cada rutina y para la limpieza posterior.

Los siguientes métodos están definidos en la clase TestCase:

No Señor.	Método y descripción
1	setUp() Método llamado para preparar el dispositivo de prueba. Esto se llama inmediatamente antes de llamar al método de prueba.
2	tearDown() Método llamado inmediatamente después de que se haya llamado al método de prueba y se haya registrado el resultado. Esto se llama incluso si el método de prueba generó una excepción,
3	setUpClass() Un método de clase llamado antes de las pruebas en una ejecución de clase individual.
4	tearDownClass() Un método de clase llamado después de que se hayan ejecutado las pruebas en una clase individual.
5	run(result = None) Ejecute la prueba, recopilando el resultado en el objeto de resultado de la prueba aprobado como resultado .
6	skipTest(reason) Llamar a esto durante un método de prueba o setUp () omite la prueba actual.
7	debug() Ejecute la prueba sin recopilar el resultado.
8	shortDescription() Devuelve una descripción de una línea de la prueba.

Accesorios

Puede haber numerosas pruebas escritas dentro de una clase TestCase. Estos métodos de prueba pueden necesitar una conexión a la base de datos, archivos temporales u otros recursos para inicializarse. Estos se denominan accesorios. TestCase incluye un gancho especial para configurar y limpiar los accesorios necesarios para sus pruebas. Para configurar los dispositivos, anule setUp (). Para limpiar, anule tearDown ().

En el siguiente ejemplo, se escriben dos pruebas dentro de la clase TestCase. Prueban el resultado de la suma y la resta de dos valores. El método setup () inicializa los argumentos basados ​​en shortDescription () de cada prueba. El método teardown () se ejecutará al final de cada prueba.

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()

Ejecute el código anterior desde la línea de comando. Da la siguiente salida:

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)

Accesorio de clase

La clase TestCase tiene un método setUpClass () que se puede anular para ejecutar antes de la ejecución de pruebas individuales dentro de una clase TestCase. De manera similar, el método tearDownClass () se ejecutará después de todas las pruebas en la clase. Ambos métodos son métodos de clase. Por lo tanto, deben decorarse con la directiva @classmethod.

El siguiente ejemplo demuestra el uso de estos métodos de clase:

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()

Clase TestSuite

El marco de prueba de Python proporciona un mecanismo útil mediante el cual las instancias de casos de prueba se pueden agrupar de acuerdo con las características que prueban. Este mecanismo está disponible mediante la clase TestSuite en el módulo unittest.

Los siguientes pasos están involucrados en la creación y ejecución de un conjunto de pruebas.

Step 1 - Cree una instancia de la clase TestSuite.

suite = unittest.TestSuite()

Step 2 - Agregue pruebas dentro de una clase TestCase en la suite.

suite.addTest(testcase class)

Step 3 - También puede usar el método makeSuite () para agregar pruebas de una clase

suite = unittest.makeSuite(test case class)

Step 4 - También se pueden agregar pruebas individuales en la suite.

suite.addTest(testcaseclass(""testmethod")

Step 5 - Crea un objeto de la clase TestTestRunner.

runner = unittest.TextTestRunner()

Step 6 - Llame al método run () para ejecutar todas las pruebas en la suite

runner.run (suite)

Los siguientes métodos están definidos en la clase TestSuite:

No Señor.	Método y descripción
1	addTest() Agrega un método de prueba en la suite de pruebas.
2	addTests() Agrega pruebas de varias clases de TestCase.
3	run() Ejecuta las pruebas asociadas con esta suite y recopila el resultado en el objeto de resultado de la prueba.
4	debug() Ejecuta las pruebas asociadas con esta suite sin recopilar el resultado.
5	countTestCases() Devuelve el número de pruebas representadas por este objeto de prueba.

El siguiente ejemplo muestra cómo utilizar la clase 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)

Puede experimentar con el método addTest () descomentando las líneas y la declaración de comentario con el método makeSuite ().

Clase TestLoader

El paquete unittest tiene la clase TestLoader que se utiliza para crear conjuntos de pruebas a partir de clases y módulos. De forma predeterminada, la instancia unittest.defaultTestLoader se crea automáticamente cuando se llama al método unittest.main (0. Sin embargo, una instancia explícita permite la personalización de ciertas propiedades.

En el siguiente código, las pruebas de dos clases se recopilan en una lista mediante el objeto 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)

La siguiente tabla muestra una lista de métodos en la clase TestLoader:

No Señor	Método y descripción
1	loadTestsFromTestCase() Devuelve un conjunto de todos los casos de prueba contenidos en una clase TestCase
2	loadTestsFromModule() Devuelve un conjunto de todos los casos de prueba contenidos en el módulo dado.
3	loadTestsFromName() Devuelve un conjunto de todos los casos de prueba dado un especificador de cadena.
4	discover() Encuentre todos los módulos de prueba recurriendo a subdirectorios del directorio de inicio especificado y devuelva un objeto TestSuite

Clase TestResult

Esta clase se utiliza para recopilar información sobre las pruebas que han tenido éxito y las que han fallado. Un objeto TestResult almacena los resultados de un conjunto de pruebas. El método TestRunner.run () devuelve una instancia de TestResult.

Las instancias de TestResult tienen los siguientes atributos:

No Señor.	Atributo y descripción
1	Errors Una lista que contiene 2 tuplas de instancias de TestCase y cadenas que contienen rastreos formateados. Cada tupla representa una prueba que generó una excepción inesperada.
2	Failures Una lista que contiene 2 tuplas de instancias de TestCase y cadenas que contienen rastreos con formato. Cada tupla representa una prueba en la que se señaló explícitamente una falla mediante los métodos TestCase.assert * ().
3	Skipped Una lista que contiene 2 tuplas de instancias de TestCase y cadenas que contienen el motivo para omitir la prueba.
4	wasSuccessful() Devuelve True si todas las pruebas ejecutadas hasta ahora han pasado; de lo contrario, devuelve False.
5	stop() Se puede llamar a este método para indicar que se debe cancelar el conjunto de pruebas que se están ejecutando.
6	startTestRun() Se llama una vez antes de que se ejecuten las pruebas.
7	stopTestRun() Se llama una vez después de ejecutar todas las pruebas.
8	testsRun El número total de pruebas realizadas hasta el momento.
9	Buffer Si se establece en verdadero, sys.stdout y sys.stderrse almacenará en búfer entre startTest () y stopTest () que se llaman.

El siguiente código ejecuta un conjunto de pruebas:

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"

El código cuando se ejecuta muestra la siguiente salida:

---- 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