unittest — Infraestructura de tests unitarios

Código fuente: Lib/unittest/__init__.py

---

(Si ya estás familiarizado con los conceptos básicos de realización de tests, puedes saltar a la lista de métodos de aserción.)

La infraestructura de tests unitarios unittest se inspiró en primera instancia en JUnit y ofrece aspectos similares a las principales estructuras de tests unitarios más importantes de otros lenguajes. Da soporte a automatización de tests, inicialización compartida, código de cierre de los tests, agregación de los tests en colecciones e independencia de los tests de la infraestructura que los reporta.

Para conseguir esto, unittest da soporte a ciertos conceptos importantes de una forma orientada a objetos:

configuración de prueba (fixture)

Un test fixture representa los preparativos para realizar una o más pruebas y las acciones de limpieza asociadas. Esto puede incluir, por ejemplo, la creación de bases de datos temporales, directorios o el arranque de procesos del servidor.

caso de prueba

Un test case es la unidad mínima de prueba. Verifica la respuesta específica a un juego particular de entradas. unittest proporciona una clase base, TestCase, que se puede utilizar para crear nuevos casos de uso.

conjunto de pruebas

Un test suite es una colección de casos de prueba, juegos de prueba o ambos. Se usa para agrupar pruebas que se han de ejecutar juntas.

ejecutor de pruebas

Un test runner es un componente que dirige la ejecución de las pruebas y proporciona un resultado. El ejecutor puede disponer de una interfaz gráfica, de texto o devolver un valor especial que indique el resultado de la ejecución de las pruebas.

Ver también

Módulo doctest

Otro módulo de soporte a pruebas con una solución muy diferente.

Simple Smalltalk Testing: With Patterns

El documento original de Kent Beck sobre infraestructuras de prueba mediante el patrón que utiliza unittest.

pytest

Una infraestructura de pruebas unitarias de otro proveedor con una sintaxis más ligera de escritura de pruebas, por ejemplo: assert func(10) == 42.

The Python Testing Tools Taxonomy

Una lista extensa de herramientas de prueba para Python incluyendo infraestructuras de pruebas funcionales y librerías de objetos sucedáneos.

Testing in Python Mailing List

Grupo especializado en debate sobre las pruebas y las herramientas de prueba de Python.

El script Tools/unittestgui/unittestgui.py de la distribución de fuentes de Python es una herramienta gráfica para el descubrimiento y ejecución de pruebas. Está orientado sobre todo a principiantes en el tema de pruebas. Para entornos de producción se recomienda que las pruebas sean dirigidas por un sistema de integración continua como Buildbot, Jenkins o Hudson.

Ejemplo sencillo

El módulo unittest proporciona un conjunto de herramientas para construir y ejecutar pruebas. Esta sección demuestra que un pequeño subconjunto de las herramientas es suficiente para satisfacer las necesidades de la mayoría.

He aquí un breve script para probar estros tres métodos de cadena:

import unittest

class TestStringMethods(unittest.TestCase):

    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def test_isupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

    def test_split(self):
        s = 'hello world'
        self.assertEqual(s.split(), ['hello', 'world'])
        # check that s.split fails when the separator is not a string
        with self.assertRaises(TypeError):
            s.split(2)

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

Para crear un caso de prueba se genera una subclase de unittest.TestCase. Las tres pruebas se definen con métodos cuyos nombres comienzan por las letras test. Esta convención sobre nombres indica al ejecutor de pruebas qué métodos representan pruebas.

El quid de cada test es la llamada a assertEqual() para verificar un resultado esperado; assertTrue() o assertFalse() para verificar una condición; o assertRaises() para asegurar que se lanza una excepción específica. Se utilizan estos métodos en lugar de la sentencia assert para que el ejecutor de pruebas pueda acumular todos los resultados de la prueba de cara a realizar un informe.

Los métodos setUp() y tearDown() permiten definir instrucciones que han de ser ejecutadas antes y después, respectivamente, de cada método de prueba. Se describen con mas detalle en la sección Organización del código de pruebas.

El bloque final muestra un modo sencillo de ejecutar las pruebas. unittest.main() proporciona una interfaz de línea de órdenes para el script de prueba. Cuando se ejecuta desde la línea de órdenes, el script anterior produce una salida como:

...
----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Si se le pasa una opción -v al script de prueba, se establecerá un nivel mayor de detalle del proceso de unittest.main() y se obtendrá la siguiente salida:

test_isupper (__main__.TestStringMethods) ... ok
test_split (__main__.TestStringMethods) ... ok
test_upper (__main__.TestStringMethods) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

Los ejemplos anteriores muestra las características más usuales de unittest, que son suficientes para solventar las necesidades cotidianas de pruebas. El resto de la documentación explora el juego completo de características, que abundan en los mismos principios.

Interfaz de línea de comandos

Se puede usar el módulo unittest desde la línea de órdenes para ejecutar pruebas de módulos, clases o hasta métodos de prueba individuales:

python -m unittest test_module1 test_module2
python -m unittest test_module.TestClass
python -m unittest test_module.TestClass.test_method

Se puede pasar una lista con cualquier combinación de nombres de módulo, así como clases o métodos completamente cualificados.

Se puede especificar los módulos de prueba por ruta de fichero también:

python -m unittest tests/test_something.py

Esto permite usar el completado automático de nombre de fichero de la shell para especificar el módulo de pruebas. El fichero especificado aún debe ser susceptible de importarse como módulo. La ruta se convierte en nombre de módulo eliminando “.py” y convirtiendo el separador de directorios por “.”. Si se desea ejecutar un fichero de prueba que no se puede importar como módulo, se ha de ejecutar el fichero directamente.

Se pueden ejecutar las pruebas con más nivel de detalle (mayor verbosidad) pasando el parámetro -v:

python -m unittest -v test_module

Cuando se ejecuta sin argumentos, se inicia Descubrimiento de pruebas:

python -m unittest

Para obtener una lista de todas las opciones de línea de órdenes:

python -m unittest -h

Distinto en la versión 3.2: En versiones anteriores sólo era posible ejecutar métodos de prueba individuales, pero no módulos ni clases.

Opciones de la línea de órdenes

unittest da soporte a las siguientes opciones de línea de órdenes:

-b, --buffer

Los flujos de datos de salida estándar y error estándar se acumulan en un búfer durante la ejecución de pruebas. La salida de las pruebas correctas se descarta. La salida de las pruebas que fallan o devuelven un error se añade a los mensajes de fallo.

-c, --catch

La pulsación de Control-C durante la ejecución de pruebas espera a que termine la prueba en curso y da un informe de los resultados hasta ese momento. Una segunda pulsación de Control-C lanza la excepción KeyboardInterrupt usual.

Consultar en Gestión de señales las funciones que proporcionan esta funcionalidad.

-f, --failfast

Finaliza la ejecución tras el primer error o fallo.

-k

Only run test methods and classes that match the pattern or substring. This option may be used multiple times, in which case all test cases that match any of the given patterns are included.

Los patrones que contengan un comodín (*) se comprueban contra el nombre de la prueba usando fnmatch.fnmatchcase(); si no lo contienen, se usa una comprobación de contenido simple sensible a mayúsculas.

Los patrones se comprueban contra el nombre del método completamente cualificado como lo importa el cargador de pruebas.

Por ejemplo, -k foo coincide con foo_tests.SomeTest.test_something y con bar_tests.SomeTest.test_foo, pero no con bar_tests.FooTest.test_something.

--locals

Mostrar las variables locales en las trazas.

Nuevo en la versión 3.2: Se añadieron las opciones de línea de órdenes -b, -c y -f.

Nuevo en la versión 3.5: La opción de línea de órdenes --locals.

Nuevo en la versión 3.7: La opción de línea de órdenes -k.

La línea de órdenes también se puede usar para descubrimiento de pruebas, para ejecutar todas las pruebas de un proyecto o un subconjunto de éstas.

Descubrimiento de pruebas

Nuevo en la versión 3.2.

Unittest da soporte al descubrimiento de pruebas simples. Para ser compatible con el descubrimiento de pruebas, todos los ficheros de prueba deben ser módulos o paquetes (incluyendo paquetes nominales) importables desde el directorio superior del proyecto (por lo que sus nombres han de ser identificadores válidos).

El descubrimiento de pruebas está implementado en TestLoader.discover(), pero también se puede usar desde la línea de órdenes. La línea de órdenes básica es:

cd project_directory
python -m unittest discover

Nota

Como atajo, python -m unittest es el equivalente de python -m unittest discover. Si se desea pasar argumentos al descubrimiento de pruebas, hay que pasar la sub-orden discover explícitamente.

La sub-orden discover cuenta con las siguientes opciones:

-v, --verbose

Salida verbosa

-s, --start-directory directory

Directorio de inicio para el descubrimiento (. si se omite)

-p, --pattern pattern

Patrón para la búsqueda de ficheros de prueba (test*.py si se omite)

-t, --top-level-directory directory

Directorio superior del proyecto (el directorio inicial si se omite)

Las opciones -s, -p, y -t se pueden pasar por posición en el orden mostrado. Las siguientes líneas de órdenes son equivalentes:

python -m unittest discover -s project_directory -p "*_test.py"
python -m unittest discover project_directory "*_test.py"

Además de pasar una ruta, es posible pasar el nombre de un paquete, por ejemplo myproject.subpackage.test, como directorio de inicio. El nombre de paquete proporcionado será importado y su ubicación en el sistema de archivos será utilizada como directorio de inicio.

Prudencia

El descubrimiento de pruebas carga las pruebas importándolas. Una vez que el descubrimiento ha encontrado todos los ficheros de prueba a partir del directorio inicial, especificado, convierte las rutas en nombres de paquetes a importar. Por ejemplo, foo/bar/baz.py será importado como foo.bar.baz.

Si hay un paquete instalado globalmente y se intenta hacer un descubrimiento sobre una copia diferente a la instalada del paquete, podría ocurrir que se importe la versión incorrecta. Si ocurre esto, el descubrimiento lanza una advertencia y abandona.

Si se proporciona el directorio de inicio como nombre de paquete en lugar de ruta a un directorio, el descubrimiento asume que la ubicación importada es la deseada, así que no se da la advertencia descrita.

Los módulos y paquetes de prueba pueden personalizar la carta y descubrimiento de pruebas mediante el protocolo load_tests.

Distinto en la versión 3.4: El descubrimiento de pruebas admite paquetes nominales para el directorio de inicio. Tenga en cuenta que también se necesita el directorio de nivel superior. (por ejemplo, python -m unittest discover -s root/namespace -t root).

Organización del código de pruebas

Los bloques de construcción básicos de las pruebas unitarias son los test cases, escenarios simples que se han de configurar y cuya corrección hay que comprobar. En unittest, los casos de prueba están representados por instancias de unittest.TestCase. Para crear nuevos casos de prueba, hay que escribir subclases de TestCase o usar FunctionTestCase.

El código de pruebas de una instancia de TestCase debería ser completamente autónomo, de tal modo que se pueda ejecutar aisladamente o en una combinación arbitraria con otras clases de prueba.

La subclase más simple de TestCase se limita a implementar un método test (o un método que empiece por test) para realizar código de prueba específico:

import unittest

class DefaultWidgetSizeTestCase(unittest.TestCase):
    def test_default_widget_size(self):
        widget = Widget('The widget')
        self.assertEqual(widget.size(), (50, 50))

Adviértase que para probar algo, usamos uno de los métodos assert*() proporcionados por la clase base TestCase. Si la prueba no tiene éxito, se lanzará una excepción con un mensaje explicativo y unittest identificará el caso como failure. Cualquier otra excepción se considerará un errors.

Las pruebas pueden ser muchas y su preparación puede ser repetitiva. Por suerte, se puede «sacar factor común» a la preparación implementando un método setUp(), al que la infraestructura de prueba llamará para cada prueba que se ejecute:

import unittest

class WidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget('The widget')

    def test_default_widget_size(self):
        self.assertEqual(self.widget.size(), (50,50),
                         'incorrect default size')

    def test_widget_resize(self):
        self.widget.resize(100,150)
        self.assertEqual(self.widget.size(), (100,150),
                         'wrong size after resize')

Nota

El orden en que se ejecutan las diversas pruebas se determina por orden alfabético de los nombres de métodos de prueba.

Si el método setUp() lanza una excepción mientras se ejecuta la prueba, la infraestructura considerará que la prueba ha sufrido un error y no se ejecutará el método de prueba propiamente dicho.

Análogamente, se puede proporcionar un método tearDown() que haga limpieza después de que se ejecute el método de prueba:

import unittest

class WidgetTestCase(unittest.TestCase):
    def setUp(self):
        self.widget = Widget('The widget')

    def tearDown(self):
        self.widget.dispose()

Si setUp() se ejecuta sin errores, tearDown() se ejecutará tanto si el método de prueba tuvo éxito como si no.

Un entorno de trabajo así para el código de pruebas se llama test fixture . Se crea una nueva instancia de TestCase como juego de datos de prueba que se utiliza para cada método de prueba. De este modo, setUp(), tearDown() y __init__() se llamarán una vez por prueba.

Se recomienda usar implementaciones de TestCase para agrupar las pruebas de acuerdo con las características probadas. unittest proporciona una mecanismo para esto: el test suite, representado por la clase TestSuite de unittest. En la mayor parte de los casos, llamar a unittest.main() hará lo correcto y recolectará todos los casos de prueba del módulo para su ejecución.

Sin embargo, si se desea personalizar la construcción del paquete de pruebas, se puede hacer:

def suite():
    suite = unittest.TestSuite()
    suite.addTest(WidgetTestCase('test_default_widget_size'))
    suite.addTest(WidgetTestCase('test_widget_resize'))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    runner.run(suite())

Se puede poner las definiciones de los casos de prueba y de los paquetes de prueba en los mismos módulos que el código que prueban.(tal como widget.py), pero sacarlos a un módulo aparte como test_widget.py tiene diversas ventajas:

• El módulo de pruebas se puede ejecutar aisladamente desde la línea de órdenes.

• El código de pruebas se puede separar con más facilidad del código de producción.

• Disminuye la tentación de cambiar el código de prueba para ajustarse al código bajo prueba.

• El código de pruebas debería modificarse con mucha menor frecuencia que el código bajo prueba.

• Es más sencillo refactorizar el código bajo prueba.

• El código para probar módulos escritos en C ha de estar en módulos aparte, así que ¿por qué no mantener la consistencia?

• Si cambia la estrategia de prueba, no hay razón para cambiar el código fuente principal.

Reutilización de código de prueba anterior

Habrá personas que tengan código de prueba previo que deseen ejecutar desde unittest, sin conversión previa de cada antigua función de prueba a una subclase de TestCase.

Por esto, unittest proporciona una clase FunctionTestCase. Se puede utilizar esta subclase de TestCase para envolver una función de prueba existente. Se pueden proporcionar también funciones de preparación y desmontaje.

Dada la siguiente función de prueba:

def testSomething():
    something = makeSomething()
    assert something.name is not None
    # ...

se puede crear una instancia de caso de prueba de la siguiente manera, con métodos opcionales de preparación y desmontaje:

testcase = unittest.FunctionTestCase(testSomething,
                                     setUp=makeSomethingDB,
                                     tearDown=deleteSomethingDB)

Nota

Aunque se puede usar FunctionTestCase para convertir rápidamente unas pruebas existentes a un sistema basado en unittest, no es una vía recomendada. Tomarse el tiempo de construir subclases bien construidas de TestCase hará las futuras refactorizaciones de pruebas futura considerablemente más fácil.

En algunos casos, los tests existentes pueden haber sido escritos usando el módulo doctest. En ese caso, doctest tiene una clase DocTestSuite que puede construir automáticamente instancias de unittest.TestSuite partiendo de los test basados en doctest.

Omitir tests y fallos esperados

Nuevo en la versión 3.1.

Unittest soporta omitir métodos individuales de tests e incluso clases completas de tests. Además, soporta marcar un test como un «fallo esperado», un test que está roto y va a fallar, pero no debería ser contado como fallo en TestResult.

Omitir un test es solo cuestión de emplear el decorator skip() o una de sus variantes condicionales, llamando a TestCase.skipTest() dentro de setUp() o en un método de test, o lanzando SkipTest directamente.

La omisión más básica tiene la siguiente forma:

class MyTestCase(unittest.TestCase):

    @unittest.skip("demonstrating skipping")
    def test_nothing(self):
        self.fail("shouldn't happen")

    @unittest.skipIf(mylib.__version__ < (1, 3),
                     "not supported in this library version")
    def test_format(self):
        # Tests that work for only a certain version of the library.
        pass

    @unittest.skipUnless(sys.platform.startswith("win"), "requires Windows")
    def test_windows_support(self):
        # windows specific testing code
        pass

    def test_maybe_skipped(self):
        if not external_resource_available():
            self.skipTest("external resource not available")
        # test code that depends on the external resource
        pass

Esta es la salida de ejecutar el ejemplo superior en modo verboso:

test_format (__main__.MyTestCase) ... skipped 'not supported in this library version'
test_nothing (__main__.MyTestCase) ... skipped 'demonstrating skipping'
test_maybe_skipped (__main__.MyTestCase) ... skipped 'external resource not available'
test_windows_support (__main__.MyTestCase) ... skipped 'requires Windows'

----------------------------------------------------------------------
Ran 4 tests in 0.005s

OK (skipped=4)

Las clases pueden ser omitidas igual que los métodos:

@unittest.skip("showing class skipping")
class MySkippedTestCase(unittest.TestCase):
    def test_not_run(self):
        pass

TestCase.setUp() puede omitir también el test. Esto es útil cuando un recurso que necesita ser puesto a punto no está disponible.

Los fallos esperados emplean el decorador expectedFailure().

class ExpectedFailureTestCase(unittest.TestCase):
    @unittest.expectedFailure
    def test_fail(self):
        self.assertEqual(1, 0, "broken")

Es fácil lanzar tus propios decoradores que omitan haciendo un decorador que llame a skip() en el test cuando quiere ser omitido. Este decorador omite el test a menos que el objeto pasado tenga un cierto atributo:

def skipUnlessHasattr(obj, attr):
    if hasattr(obj, attr):
        return lambda func: func
    return unittest.skip("{!r} doesn't have {!r}".format(obj, attr))

Los siguientes decoradores y la excepción implementan la omisión de tests y los fallos esperados:

@unittest.skip(reason)

Omitir incondicionalmente el test decorado. reason debe describir porqué el test está siendo omitido.

@unittest.skipIf(condition, reason)

Omitir el test decorado si condition es verdadero.

@unittest.skipUnless(condition, reason)

Omitir el test decorado a menos que condition sea verdadero.

@unittest.expectedFailure

Marca el test como un fallo esperado. Si falla el test o hay errores en la función de test misma (en lugar de en alguno de los métodos test fixture) será considerado un éxito. Si el test pasa, será considerado un fallo.

exception unittest.SkipTest(reason)

Esta excepción es lanzada para omitir un test.

Normalmente puedes usar directamente TestCase.skipTest() o uno de los decoradores de omisión en vez de lanzar esta excepción.

Los tests omitidos no ejecutarán setUp() o tearDown(). Las clases omitidas no ejecutarán setUpClass() o tearDownClass(). Los módulos omitidos no ejecutarán setUpModule() o tearDownModule().

Distinguiendo iteraciones de tests empleando subtests

Nuevo en la versión 3.4.

Cuando hay diferencias muy pequeñas entre tus tests, por ejemplo algunos parámetros, unittest te permite distinguirlos dentro del cuerpo de un método de test empleando el administrador de contexto subTest() .

Por ejemplo, el siguiente test:

class NumbersTest(unittest.TestCase):

    def test_even(self):
        """
        Test that numbers between 0 and 5 are all even.
        """
        for i in range(0, 6):
            with self.subTest(i=i):
                self.assertEqual(i % 2, 0)

producirá la siguiente salida:

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=3)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_even (__main__.NumbersTest) (i=5)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Sin usar un subtest, la ejecución se pararía después del primer fallo, y el error sería más difícil de diagnosticar porque el valor de i no se mostraría:

======================================================================
FAIL: test_even (__main__.NumbersTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "subtests.py", line 32, in test_even
    self.assertEqual(i % 2, 0)
AssertionError: 1 != 0

Clases y funciones

Esta sección describe en detalle la API de unittest.

Casos de test

class unittest.TestCase(methodName='runTest')

Las instancias de la clase TestCase representan las unidades lógicas de test en el universo de unittest. Esta clase está pensada para ser utilizada como clase base, con los test específicos siendo implementados por subclases concretas. Esta clase implementa la interfaz que necesita el ejecutor de tests para permitirle llevar a cabo los tests, y métodos que el código de test puede utilizar para chequear y reportar distintos tipos de fallo.

Cada instancia de TestCase ejecutará un solo método base: el método llamado methodName. En la mayoría de usos de TestCase, no tendrás que cambiar el methodName ni reimplementar el método por defecto runTest().

Distinto en la versión 3.2: TestCase puede instancias con éxito sin dar un methodName. Esto permite experimentar de manera sencilla con TestCase en el intérprete interactivo.

Las instancias de TestCase proveen tres grupos de métodos: un grupo empleado para ejecutar el test, otro usado para que la implementación del test chequee condiciones y reporte fallos, y algunos métodos de indagación que permiten recopilar información sobre el test en si mismo.

Los métodos en el primer grupo (ejecutando el test) son:

setUp()

Método llamado para preparar el banco de test. Es invocado inmediatamente antes de llamar al método de test; cualquier excepción lanzada por este método que no sea AssertionError o SkipTest será considerada un error en vez de un fallo del test. La implementación por defecto no hace nada.

tearDown()

Método llamado inmediatamente después de que se haya llamado el método de prueba y se haya registrado el resultado. Se llama así aunque el método de ensayo haya planteado una excepción, por lo que la aplicación en las subclases puede tener que ser especialmente cuidadosa en cuanto a la comprobación del estado interno. Cualquier excepción, que no sea AssertionError o SkipTest, planteada por este método se considerará un error adicional en lugar de un fallo de la prueba (aumentando así el número total de errores reportados). Este método sólo se llamará si setUp() tiene éxito, independientemente del resultado del método de prueba. La implementación por defecto no hace nada.

setUpClass()

Un método de clase llamado antes de que los tests en una clase individual sean ejecutados. setUpClass es llamado con la clase como el único argumento y debe ser decorada como classmethod():

@classmethod
def setUpClass(cls):
    ...

Vea Class and Module Fixtures para más detalles.

Nuevo en la versión 3.2.

tearDownClass()

Un método de clase llamado después de que se hayan realizado tests en una clase individual. tearDownClass se llama con la clase como único argumento y debe ser decorado como un classmethod():

@classmethod
def tearDownClass(cls):
    ...

Vea Class and Module Fixtures para más detalles.

Nuevo en la versión 3.2.

run(result=None)

Ejecutar la prueba, recogiendo el resultado en el objeto TestResult pasado como result. Si se omite result o None, se crea un objeto resultado temporal (llamando al método defaultTestResult()) y se emplea ese. El objeto resultante se devuelve al invocador de run().

El mismo efecto puede conseguirse simplemente llamando a la instancia TestCase.

Distinto en la versión 3.3: Las versiones previas de run no retornaban el resultado. Tampoco lo hacía la llamada a una instancia.

skipTest(reason)

Llamar a esto durante un método de prueba o setUp() se salta el test actual. Ver Omitir tests y fallos esperados para más información.

Nuevo en la versión 3.1.

subTest(msg=None, **params)

Retorna un gestor de contexto que ejecuta el bloque de código adjunto como un subtest. msg y params son valores opcionales y arbitrarios que se muestran cuando falla un subtest, permitiéndole identificarlos claramente.

Un caso de test puede contener cualquier número de declaraciones de subtest, y pueden anidarse arbitrariamente.

Ver Distinguiendo iteraciones de tests empleando subtests para más información.

Nuevo en la versión 3.4.

debug()

Realice el test sin recoger el resultado. Esto permite que las excepciones planteadas por el test se propaguen al invocado, y puede utilizarse para apoyar la ejecución de tests bajo un depurador.

La clase TestCase proporciona varios métodos de afirmación para comprobar y reportar fallos. En la siguiente tabla se enumeran los métodos más utilizados (consulte las tablas siguientes para ver más métodos de afirmación):

Método	Comprueba que	Nuevo en
assertEqual(a, b)	a == b
assertNotEqual(a, b)	a != b
assertTrue(x)	bool(x) is True
assertFalse(x)	bool(x) is False
assertIs(a, b)	a is b	3.1
assertIsNot(a, b)	a is not b	3.1
assertIsNone(x)	x is None	3.1
assertIsNotNone(x)	x is not None	3.1
assertIn(a, b)	a in b	3.1
assertNotIn(a, b)	a not in b	3.1
assertIsInstance(a, b)	isinstance(a, b)	3.2
assertNotIsInstance(a, b)	not isinstance(a, b)	3.2

Todos los métodos de aserción aceptan un argumento msg que, si se especifica, se utiliza como mensaje de error en caso de fallo (véase también longMessage). Tenga en cuenta que el argumento de la palabra clave msg puede pasarse a assertRaises(), assertRaisesRegex(), assertWarns(), assertWarnsRegex() sólo cuando se utilizan como gestor de contexto.

assertEqual(first, second, msg=None)

Testea que first y second son iguales. Si los valores no comparan como iguales, el test fallará.

Además, si first y second son exactamente del mismo tipo y uno de lista, tuple, dict, set, frozenset o str o cualquier tipo que una subclase registre con addTypeEqualityFunc() se llamará a la función de igualdad específica del tipo para generar un mensaje de error por defecto más útil (véase también la lista de métodos específicos del tipo).

Distinto en la versión 3.1: Añadida la llamada automática de la función de igualdad de tipo específico.

Distinto en la versión 3.2: assertMultiLineEqual() añadido como la función por defecto para igualdad de tipos cuando se comparan cadenas.

assertNotEqual(first, second, msg=None)

Testea que first y second no son iguales. Si los valores son iguales, el test fallará.

assertTrue(expr, msg=None)

assertFalse(expr, msg=None)

Testea que expr es verdadero (o falso).

Note que esto es equivalente a bool(expr) is True y no a expr is True (use assertIs(expr, True) para lo último). Este método también debe evitarse cuando se disponga de métodos más específicos (por ejemplo, assertEqual(a, b) en lugar de assertTrue(a == b)), porque proporcionan un mejor mensaje de error en caso de fallo.

assertIs(first, second, msg=None)

assertIsNot(first, second, msg=None)

Testea si first y second son (o no) el mismo objeto.

Nuevo en la versión 3.1.

assertIsNone(expr, msg=None)

assertIsNotNone(expr, msg=None)

Testea que expr es (o no es) None.

Nuevo en la versión 3.1.

assertIn(member, container, msg=None)

assertNotIn(member, container, msg=None)

Testea que member está (o no está) en container.

Nuevo en la versión 3.1.

assertIsInstance(obj, cls, msg=None)

assertNotIsInstance(obj, cls, msg=None)

Testea que obj es (o no es) una instancia de cls (que puede ser una clase o una tupla de clases, de la misma forma que soporta isinstance()). Para chequear por el tipo exacto, use assertIs(type(obj), cls).

Nuevo en la versión 3.2.

Es también posible chequear la producción de excepciones, advertencias y mensajes de log usando los siguientes métodos:

Método	Comprueba que	Nuevo en
assertRaises(exc, fun, *args, **kwds)	fun(*args, **kwds) lanza exc
assertRaisesRegex(exc, r, fun, *args, **kwds)	fun(*args, **kwds) lanza exc y el mensaje coincide con regex r	3.1
assertWarns(warn, fun, *args, **kwds)	fun(*args, **kwds) lanza warn	3.2
assertWarnsRegex(warn, r, fun, *args, **kwds)	fun(*args, **kwds) lanza warn y el mensaje coincide con regex r	3.2
assertLogs(logger, level)	El bloque with vuelca sus logs a logger con el level mínimo	3.4
assertLogs(logger, level)	El bloque with no ingresa El bloque with vuelca sus logs a logger con el level mínimo	3.10

assertRaises(exception, callable, *args, **kwds)

assertRaises(exception, *, msg=None)

Testea que se lanza una excepción cuando se llama a callable con cualquier argumento posicional o de palabra clave que también se pasa a assertRaises(). El test pasa si se lanza exception, es un error si se lanza otra excepción, o falla si no se lanza ninguna excepción. Para tener en cuenta cualquiera de un grupo de excepciones, una tupla que contenga las clases de excepción puede ser pasada como exception.

Si sólo se dan los argumentos de exception y posiblemente msg, retorna un administrador de contexto para que el código testado pueda ser escrito en línea en lugar de como una función:

with self.assertRaises(SomeException):
    do_something()

Cuando se emplea como un administrador de contexto, assertRaises() acepta el argumento por palabra clave adicional msg.

El gestor de contexto almacenará el objeto de excepción capturado en su atributo exception . Esto puede ser útil si la intención es realizar comprobaciones adicionales sobre la excepción planteada:

with self.assertRaises(SomeException) as cm:
    do_something()

the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

Distinto en la versión 3.1: Añadió la capacidad de usar assertRaises() como gestor de contexto.

Distinto en la versión 3.2: Añadido el atributo exception .

Distinto en la versión 3.3: Añadido el argumento por palabra clave msg cuando se emplea un gestor de contexto.

assertRaisesRegex(exception, regex, callable, *args, **kwds)

assertRaisesRegex(exception, regex, *, msg=None)

Como assertRaises() pero también testea que regex coincide en la representación de la cadena de la excepción planteada. regex puede ser un objeto de expresión regular o una cadena que contiene una expresión regular adecuada para ser usada por re.search(). Ejemplos:

self.assertRaisesRegex(ValueError, "invalid literal for.*XYZ'$",
                       int, 'XYZ')

o:

with self.assertRaisesRegex(ValueError, 'literal'):
   int('XYZ')

Nuevo en la versión 3.1: Añadido bajo el nombre de assertRaisesRegexp.

Distinto en la versión 3.2: Renombrado a assertRaisesRegex().

Distinto en la versión 3.3: Añadido el argumento por palabra clave msg cuando se emplea un gestor de contexto.

assertWarns(warning, callable, *args, **kwds)

assertWarns(warning, *, msg=None)

Testea que una advertencia se activa cuando se llama a callable con cualquier argumento posicional o de palabra clave que también se pasa a assertWarns(). El test pasa si se activa el warning y falla si no lo hace. Cualquier excepción es un error. Para considerar cualquiera de un grupo de advertencias, una tupla que contenga las clases de advertencia puede ser pasada como warnings.

Si sólo se dan los argumentos de advertencia y msg, retorna un gestor de contexto para que el código testado pueda ser escrito en línea en lugar de como una función:

with self.assertWarns(SomeWarning):
    do_something()

Cuando se usa como gestor de contexto, assertWarns() acepta el argumento de palabra clave adicional msg.

El gestor de contexto almacenará el objeto de advertencia capturado en su atributo warning, y la línea del código que disparó las advertencias en los atributos filename y lineno . Esto puede ser útil si la intención es realizar comprobaciones adicionales sobre la advertencia capturada:

with self.assertWarns(SomeWarning) as cm:
    do_something()

self.assertIn('myfile.py', cm.filename)
self.assertEqual(320, cm.lineno)

Este método funciona independientemente de los filtros de aviso que estén en su lugar cuando se llame.

Nuevo en la versión 3.2.

Distinto en la versión 3.3: Añadido el argumento por palabra clave msg cuando se emplea un gestor de contexto.

assertWarnsRegex(warning, regex, callable, *args, **kwds)

assertWarnsRegex(warning, regex, *, msg=None)

Como assertWarns() pero también testea que regex coincide en el mensaje del aviso disparado. regex puede ser un objeto de expresión regular o una cadena que contiene una expresión regular adecuada para ser usada por re.search(). Ejemplo:

self.assertWarnsRegex(DeprecationWarning,
                      r'legacy_function\(\) is deprecated',
                      legacy_function, 'XYZ')

o:

with self.assertWarnsRegex(RuntimeWarning, 'unsafe frobnicating'):
    frobnicate('/etc/passwd')

Nuevo en la versión 3.2.

Distinto en la versión 3.3: Añadido el argumento por palabra clave msg cuando se emplea un gestor de contexto.

assertLogs(logger=None, level=None)

Un gestor de contexto para comprobar que al menos un mensaje está registrado en el logger o en uno de sus hijos, con al menos el level dado.

Si se da, logger debería ser un objeto logging.Logger o un str dando el nombre de un logger. El valor por defecto es el root logger, que captará todos los mensajes.

Si se da, level debe ser un nivel de logging numérico o su equivalente en cadena (por ejemplo, o bien ”ERROR” o logging.ERROR). El valor por defecto es logging.INFO.

El test pasa si al menos un mensaje emitido dentro del bloque with coincide con las condiciones de logger y level, de lo contrario falla.

El objeto devuelto por el gestor de contexto es un ayudante de grabación que lleva un registro de los mensajes de registro que coinciden. Tiene dos atributos:

records

Una lista de objetos logging.LogRecord de los mensajes de log coincidentes.

output

Una lista de objetos str con la salida forrajeada en los mensajes coincidentes.

Ejemplo:

with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
                             'ERROR:foo.bar:second message'])

Nuevo en la versión 3.4.

assertNoLogs(logger=None, level=None)

Un gestor de contexto para comprobar que al menos un mensaje está registrado en el logger o en uno de sus hijos, con al menos el level dado.

Si se da, logger debería ser un objeto logging.Logger o un str dándole el nombre de un logger. El valor por defecto es el root logger, que captará todos los mensajes.

Si se da, level debe ser un nivel de logging numérico o su equivalente en cadena (por ejemplo, o bien ”ERROR” o logging.ERROR). El valor por defecto es logging.INFO.

A diferencia de assertLogs(), el gestor de contexto no devolverá nada.

Nuevo en la versión 3.10.

Hay también otros métodos empleados para realizar comprobaciones más específicas, tales como:

Método	Comprueba que	Nuevo en
assertAlmostEqual(a, b)	round(a-b, 7) == 0
assertNotAlmostEqual(a, b)	round(a-b, 7) != 0
assertGreater(a, b)	a > b	3.1
assertGreaterEqual(a, b)	a >= b	3.1
assertLess(a, b)	a < b	3.1
assertLessEqual(a, b)	a <= b	3.1
assertRegex(s, r)	r.search(s)	3.1
assertNotRegex(s, r)	not r.search(s)	3.2
assertCountEqual(a, b)	a y b tienen los mismos elementos y en el mismo número, sin importar su orden.	3.2

assertAlmostEqual(first, second, places=7, msg=None, delta=None)

assertNotAlmostEqual(first, second, places=7, msg=None, delta=None)

Testea que first y second son aproximadamente (o no aproximadamente) iguales calculando su diferencia, redondeando al número dado de puntos places decimales (por defecto 7), y comparado a cero. Nótese que estos métodos redondean los valores al número dado de puntos decimales (por ejemplo como la función round()) y no cifras significativas.

Si se suministra delta en vez de places que entonces la diferencia entre first y second deba ser menor o igual a (o mayor que) delta.

Suministrar tanto delta como places lanza un TypeError.

Distinto en la versión 3.2: assertAlmostEqual() considera automáticamente casi iguales a los objetos que se comparan igual. assertNotAlmostEqual() falla automáticamente si los objetos comparan iguales. Añadido el argumento de palabra clave delta.

assertGreater(first, second, msg=None)

assertGreaterEqual(first, second, msg=None)

assertLess(first, second, msg=None)

assertLessEqual(first, second, msg=None)

Prueba que first es respectivamente >, >=, < o <= que second dependiendo del nombre del método. Si no, el test fallará:

>>> self.assertGreaterEqual(3, 4)
AssertionError: "3" unexpectedly not greater than or equal to "4"

Nuevo en la versión 3.1.

assertRegex(text, regex, msg=None)

assertNotRegex(text, regex, msg=None)

Testea que una búsqueda regex coincide (o no coincide) con el text. En caso de fallo, el mensaje de error incluirá el patrón y el text (o el patrón y la parte de text que coincida inesperadamente). regex puede ser un objeto de expresión regular o una cadena que contiene una expresión regular adecuada para ser utilizada por re.search().

Nuevo en la versión 3.1: Añadido bajo el nombre de assertRegexpMatches.

Distinto en la versión 3.2: El método assertRegexpMatches() ha sido renombrado a assertRegex().

Nuevo en la versión 3.2: assertNotRegex().

Nuevo en la versión 3.5: El nombre assertNotRegexpMatches es un alias obsoleto para assertNotRegex().

assertCountEqual(first, second, msg=None)

Testea que la secuencia first contiene los mismos elementos que second, independientemente de su orden. Cuando no lo hagan, se generará un mensaje de error con las diferencias entre las secuencias.

Los elementos duplicados no son ignorados cuando se comparan first y second. Verifica si cada elemento tiene la misma cuenta en ambas secuencias. Equivalente a: assertEqual(Counter(list(first)), Counter(list(second))) pero funciona también con secuencias de objetos que no son hashable.

Nuevo en la versión 3.2.

El método assertEqual() envía la comprobación de igualdad de los objetos del mismo tipo a diferentes métodos específicos de tipo. Estos métodos ya están implementados para la mayoría de los tipos incorporados, pero también es posible registrar nuevos métodos usando addTypeEqualityFunc():

addTypeEqualityFunc(typeobj, function)

Registra un método específico de tipo llamado por assertEqual() para comprobar si dos objetos del mismo typeobj (no subclases) comparan como iguales. function debe tomar dos argumentos posicionales y un tercer argumento de palabra clave msg=None tal y como lo hace assertEqual(). Debe lanzar self.failureException(msg) cuando se detecta una desigualdad entre los dos primeros parámetros, posiblemente proporcionando información útil y explicando las desigualdades en detalle en el mensaje de error.

Nuevo en la versión 3.1.

La lista de métodos específicos de tipo utilizados automáticamente por assertEqual() se resumen en la siguiente tabla. Tenga en cuenta que normalmente no es necesario invocar estos métodos directamente.

Método	Usado para comparar	Nuevo en
assertMultiLineEqual(a, b)	strings	3.1
assertSequenceEqual(a, b)	sequences	3.1
assertListEqual(a, b)	lists	3.1
assertTupleEqual(a, b)	tuples	3.1
assertSetEqual(a, b)	sets or frozensets	3.1
assertDictEqual(a, b)	dicts	3.1

assertMultiLineEqual(first, second, msg=None)

Testea que la cadena multilínea first es igual a la cadena second. Cuando no sea igual, una diferencia de las dos cadenas que resalte las diferencias se incluirá en el mensaje de error. Este método se utiliza por defecto cuando se comparan cadenas con assertEqual().

Nuevo en la versión 3.1.

assertSequenceEqual(first, second, msg=None, seq_type=None)

Testea que dos secuencias son iguales. Si se suministra un seq_type, tanto first como second deben ser instancias de seq_type o se lanzará un fallo. Si las secuencias son diferentes se construye un mensaje de error que muestra la diferencia entre las dos.

Este método no es llamado directamente por assertEqual(), pero se usa para implementar assertListEqual() y assertTupleEqual().

Nuevo en la versión 3.1.

assertListEqual(first, second, msg=None)

assertTupleEqual(first, second, msg=None)

Testea que dos listas o tuplas son iguales. Si no es así, se construye un mensaje de error que muestra sólo las diferencias entre las dos. También se lanza un error si alguno de los parámetros es del tipo equivocado. Estos métodos se utilizan por defecto cuando se comparan listas o tuplas con assertEqual().

Nuevo en la versión 3.1.

assertSetEqual(first, second, msg=None)

Testea que dos conjuntos son iguales. Si no es así, se construye un mensaje de error que enumera las diferencias entre los conjuntos. Este método se utiliza por defecto cuando se comparan los conjuntos o frozensets con assertEqual().

Falla si cualquiera de first o second no tiene un método de set.difference().

Nuevo en la versión 3.1.

assertDictEqual(first, second, msg=None)

Testea que dos diccionarios son iguales. Si no es así, se construye un mensaje de error que muestra las diferencias en los diccionarios. Este método se usará por defecto para comparar los diccionarios en las llamadas a assertEqual().

Nuevo en la versión 3.1.

Finalmente, TestCase proporciona los siguientes métodos y atributos:

fail(msg=None)

Señala un fallo del test incondicionalmente, con msg o None para el mensaje de error.

failureException

Este atributo de clase da la excepción lanzada por el método de test. Si un marco de pruebas necesita utilizar una excepción especializada, posiblemente para llevar información adicional, debe subclasificar esta excepción para «jugar limpio» con el marco. El valor inicial de este atributo es AssertionError.

longMessage

Este atributo de clase determina lo que ocurre cuando se pasa un mensaje de fallo personalizado como el argumento msg a una llamada assertXYY que falla. True es el valor por defecto. En este caso, el mensaje personalizado se añade al final del mensaje de fallo estándar. Cuando se establece en False, el mensaje personalizado reemplaza al mensaje estándar.

La configuración de la clase puede ser anulada en los métodos de test individuales asignando un atributo de instancia, self.longMessage, a True o False antes de llamar a los métodos assert.

La configuración de la clase se reajusta antes de cada llamada de test.

Nuevo en la versión 3.1.

maxDiff

Este atributo controla la longitud máxima de las diferencias de salida de métodos assert que reportan diferencias en caso de fallo. El valor predeterminado es de 80*8 caracteres. Los métodos assert afectados por este atributo son assertSequenceEqual() (incluyendo todos los métodos de comparación de secuencias que le delegan), assertDictEqual() y assertMultiLineEqual().

Poner maxDiff en None significa que no hay una longitud máxima de diferencias.

Nuevo en la versión 3.2.

Los marcos de test pueden utilizar los siguientes métodos para reunir información sobre el test:

countTestCases()

Retorna el número de tests representados por este objeto de test. Para las instancias de TestCase, este siempre será 1.

defaultTestResult()

Retorna una instancia de la clase de resultado de test que debería utilizarse para esta clase de caso de test (si no se proporciona otra instancia de resultado al método run()).

Para las instancias de TestCase, ésta siempre será una instancia de TestResult; las subclases de TestCase deben anular esto según sea necesario.

id()

Devuelva una cadena que identifique el caso de test específico. Normalmente es el nombre completo del método de test, incluyendo el nombre del módulo y de la clase.

shortDescription()

Devuelve una descripción de la prueba, o None si no se ha proporcionado ninguna descripción. La implementación por defecto de este método devuelve la primera línea de la docstring del método de test, si está disponible, o None .

Distinto en la versión 3.1: En 3.1 esto se cambió para añadir el nombre del test a la descripción corta incluso en presencia de una docstring. Esto causó problemas de compatibilidad con las extensiones de unittest y la adición del nombre de test fue movida a la TextTestResult en Python 3.2.

addCleanup(function, /, *args, **kwargs)

Añade una función que se llamará después de tearDown() a los recursos de limpieza utilizados durante el test. Las funciones se llamarán en orden inverso al orden en que se agregan (LIFO). Se llaman con cualquier argumento y argumentos de palabra clave que se pase a addCleanup() cuando se agregan.

Si setUp() falla, lo que significa que tearDown() no se llama, entonces cualquier función de limpieza añadida seguirá siendo llamada.

Nuevo en la versión 3.1.

doCleanups()

Este método se llama incondicionalmente después de tearDown(), o después de setUp() si setUp() lanza una excepción.

Es responsable de llamar a todas las funciones de limpieza añadidas por addCleanup(). Si necesitas que las funciones de limpieza se llamen con anterioridad a tearDown() entonces puedes llamar a doCleanups() tú mismo.

doCleanups() saca los métodos de la pila de funciones de limpieza uno a uno, así que se puede llamar en cualquier momento.

Nuevo en la versión 3.1.

classmethod addClassCleanup(function, /, *args, **kwargs)

Añade una función que se llamará después de tearDownClass() para limpiar recursos utilizados durante la clase de test. Las funciones se llamarán en orden inverso al orden en que se agregan (LIFO). Se llaman con cualquier argumento y argumento de palabra clave que se pase a addClassCleanup() cuando se añadan.

Si setUpClass() falla, lo que significa que tearDownClass() no se invoca, entonces cualquier función de limpieza añadida seguirá siendo llamada.

Nuevo en la versión 3.8.

classmethod doClassCleanups()

Este método se llama incondicionalmente después de tearDownClass(), o después de setUpClass() si setUpClass() lanza una excepción.

Es responsable de llamar a todas las funciones de limpieza añadidas por addCleanupClass(). Si necesitas que las funciones de limpieza se llamen con anterioridad a tearDownClass() entonces puedes llamar a doCleanupsClass() tú mismo.

doCleanupsClass() saca los métodos de la pila de funciones de limpieza de uno en uno, así que se puede llamar en cualquier momento.

Nuevo en la versión 3.8.

class unittest.IsolatedAsyncioTestCase(methodName='runTest')

Esta clase proporciona una API similar a TestCase y también acepta corutinas como funciones de test.

Nuevo en la versión 3.8.

coroutine asyncSetUp()

Método llamado para preparar la configuración de test. Esto se llama después de setUp(). Se llama inmediatamente antes de llamar al método de test; aparte de AssertionError o SkipTest, cualquier excepción lanzada por este método se considerará un error más que un fallo del test. La implementación por defecto no hace nada.

coroutine asyncTearDown()

Método llamado inmediatamente después de que se haya llamado el método de test y se haya registrado el resultado. Esto se llama antes de tearDown(). Se llama así aunque el método de test haya lanzado una excepción, por lo que la implementación en las subclases puede necesitar ser particularmente cuidadosa en la comprobación del estado interno. Cualquier excepción, que no sea AssertionError o SkipTest, lanzada por este método se considerará un error adicional en lugar de un fallo del test (aumentando así el número total de errores reportados). Este método sólo se llamará si asyncSetUp() tiene éxito, independientemente del resultado del método de test. La implementación por defecto no hace nada.

addAsyncCleanup(function, /, *args, **kwargs)

Este método acepta una corutina que puede ser utilizada como función de limpieza.

run(result=None)

Establece un nuevo bucle de eventos para ejecutar el test, recogiendo el resultado en el objeto TestResult pasado como result. Si se omite result o None, se crea un objeto resultado temporal (llamando al método defaultTestResult()) y se utiliza. El objeto resultante se devuelve al invocado de run(). Al final del test se cancelan todas las tareas del bucle de eventos.

Un ejemplo ilustrando el orden:

from unittest import IsolatedAsyncioTestCase

events = []


class Test(IsolatedAsyncioTestCase):


    def setUp(self):
        events.append("setUp")

    async def asyncSetUp(self):
        self._async_connection = await AsyncConnection()
        events.append("asyncSetUp")

    async def test_response(self):
        events.append("test_response")
        response = await self._async_connection.get("https://example.com")
        self.assertEqual(response.status_code, 200)
        self.addAsyncCleanup(self.on_cleanup)

    def tearDown(self):
        events.append("tearDown")

    async def asyncTearDown(self):
        await self._async_connection.close()
        events.append("asyncTearDown")

    async def on_cleanup(self):
        events.append("cleanup")

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

Después de ejecutar el test, events contendría [“setUp”, “asyncSetUp”, “test_response”, “asyncTearDown”, “tearDown”, “cleanup”].

class unittest.FunctionTestCase(testFunc, setUp=None, tearDown=None, description=None)

Esta clase implementa la porción de la interfaz TestCase que permite al corredor de tests conducir los tests, pero no proporciona los métodos que el código de test puede utilizar para comprobar e informar de los errores. Se utiliza para crear casos de test utilizando código de prueba heredado, lo que permite que se integre en un marco de tests basado en unittest.

Alias obsoletos

Por razones históricas, algunos de los métodos de TestCase tenían uno o más alias que ahora están obsoletos. La siguiente tabla lista los nombres correctos junto con sus alias obsoletos:

Nombre del método	Alias deprecado	Alias deprecado
assertEqual()	failUnlessEqual	assertEquals
assertNotEqual()	failIfEqual	assertNotEquals
assertTrue()	failUnless	assert_
assertFalse()	failIf
assertRaises()	failUnlessRaises
assertAlmostEqual()	failUnlessAlmostEqual	assertAlmostEquals
assertNotAlmostEqual()	failIfAlmostEqual	assertNotAlmostEquals
assertRegex()		assertRegexpMatches
assertNotRegex()		assertNotRegexpMatches
assertRaisesRegex()		assertRaisesRegexp

Obsoleto desde la versión 3.1: Los alias de fail* que figuran en la segunda columna han sido declarados obsoletos.

Obsoleto desde la versión 3.2: Los alias de aserción* que figuran en la tercera columna han sido declarados obsoletos.

Obsoleto desde la versión 3.2: assertRegexpMatches y assertRaisesRegexp han sido renombrados a assertRegex() y assertRaisesRegex().

Obsoleto desde la versión 3.5: El nombre assertNotRegexpMatches se ha declarado obsoleto en favor de assertNotRegex().

Agrupando tests

class unittest.TestSuite(tests=())

Esta clase representa una agregación de casos de test individuales y conjuntos de tests. La clase presenta la interfaz que necesita el corredor de tests para poder ser ejecutado como cualquier otro caso de test. Ejecutar una instancia TestSuite es lo mismo que iterar sobre el conjunto, ejecutando cada test individualmente.

Si se indican tests, debe ser un iterable de casos de test individuales u otros conjuntos de tests que se usarán para construir el conjunto inicialmente. Se proporcionan métodos adicionales para añadir casos de test y conjuntos a la colección más adelante.

Los objetos de TestSuite se comportan de manera muy parecida a los objetos de TestCase, excepto que no implementan un test. En cambio, se usan para agregar tests en grupos de tests que deben ser ejecutados juntos. Existen algunos métodos adicionales para agregar tests a las instancias de TestSuite:

addTest(test)

Añade un TestCase o TestSuite al conjunto.

addTests(tests)

Añade todos los tests de un iterable de TestCase y TestSuite a este conjunto de tests.

Esto equivale a iterar sobre tests, llamando a addTest() para cada elemento.

TestSuite comparte los siguientes métodos con TestCase:

run(result)

Ejecuta los tests asociados a este conjunto, recogiendo el resultado en el objeto de resultado del test pasado como result. Tenga en cuenta que a diferencia de TestCase.run(), TestSuite.run() requiere que se pase el objeto resultado.

debug()

Ejecuta los tests asociados con este conjunto sin recoger los resultados. Esto permite que las excepciones lanzadas por este test sean propagadas al invocador y puedes ser usadas para apoyar tests que están ejecutándose con un debugger.

countTestCases()

Retorna el numero de tests representados por este objeto de test, incluidos todos los test individuales y los sub-conjuntos.

__iter__()

Los tests agrupados por una TestSuite se acceden siempre por iteración. Las subclases pueden proporcionar tests anulando __iter__(). Tenga en cuenta que este método puede ser invocado varias veces en un mismo conjunto (por ejemplo, cuando se cuentan los tests o se comparan por igualdad), por lo que los tests retornados por iteraciones repetidas antes de TestSuite.run() deben ser los mismos para cada iteración de invocación. Después de TestSuite.run(), los invocados no deben confiar en los tests retornados por este método a menos que el invocado utilice una subclase que anule TestSuite._removeTestAtIndex() para preservar las referencias de los tests.

Distinto en la versión 3.2: En versiones anteriores la TestSuite accedía a los test directamente en lugar de a través de la iteración, por lo que anular __iter__() no era suficiente para proporcionar los tests.

Distinto en la versión 3.4: En versiones anteriores, la TestSuite tenía referencias a cada TestCase después de TestSuite.run(). Las subclases pueden restaurar ese comportamiento anulando TestSuite._removeTestAtIndex().

En el uso típico de un objeto TestSuite, el método run() es invocado por un TestRunner en lugar de por el marco de test de pruebas automático del usuario final.

Cargando y ejecutando tests

class unittest.TestLoader

La clase TestLoader se utiliza para crear conjuntos de tests a partir de clases y módulos. Normalmente, no es necesario crear una instancia de esta clase; el módulo unittest proporciona una instancia que puede ser compartida como unittest.defaultTestLoader. Sin embargo, el uso de una subclase o instancia permite la personalización de algunas propiedades configurables.

Los objetos TestLoader tienen los siguientes atributos:

errors

A list of the non-fatal errors encountered while loading tests. Not reset by the loader at any point. Fatal errors are signalled by the relevant method raising an exception to the caller. Non-fatal errors are also indicated by a synthetic test that will raise the original error when run.

Nuevo en la versión 3.5.

Los objetos TestLoader tienen los siguientes métodos:

loadTestsFromTestCase(testCaseClass)

Devuelve un conjunto de todos los casos de test contenidos en la TestCasederivada de testCaseClass.

Se crea una instancia de caso de test para cada método nombrado por getTestCaseNames(). Por defecto, estos son los nombres de los métodos que comienzan con test. Si getTestCaseNames() no retorna ningún método, pero se implementa el método runTest(), se crea un único caso de test para ese método.

loadTestsFromModule(module, pattern=None)

Devuelva un conjunto de todos los casos de test contenidos en el módulo dado. Este método busca en module clases derivadas de TestCase y crea una instancia de la clase para cada método de test definido para la clase.

Nota

Aunque el uso de una jerarquía de clases derivadas de TestCase puede ser conveniente para compartir configuraciones y funciones de ayuda, la definición de métodos de test en clases base que no están destinadas a ser instanciadas directamente no complementa bien con este método. Hacerlo, sin embargo, puede ser útil cuando las configuraciones son diferentes y están definidas en subclases.

Si un módulo proporciona una función load_tests será llamado para cargar los tests. Esto permite a los módulos personalizar la carga de los tests. Este es el load_tests protocol. El argumento pattern se pasa como tercer argumento a load_tests.

Distinto en la versión 3.2: Se ha añadido soporte para load_tests.

Distinto en la versión 3.5: El argumento por defecto use_load_tests no documentado y no oficial es obsoleto e ignorado, aunque sigue siendo aceptado por la retrocompatibilidad. El método también acepta ahora un argumento de sólo palabra clave pattern que se pasa a load_tests como tercer argumento.

loadTestsFromName(name, module=None)

Retorna un conjunto de todos los casos de test dado un especificador de cadena.

El especificador name es un «nombre punteado» que puede resolverse ya sea a un módulo, una clase de caso de test, un método de test dentro de una clase de caso de test, una instancia TestSuite, o un objeto invocable que devuelve una instancia TestCase o TestSuite. Estas comprobaciones se aplican en el orden que se indica aquí; es decir, un método en una posible clase de caso de test se recogerá como «un método de test dentro de una clase de caso de test”, en lugar de «un objeto invocable”.

Por ejemplo, si tiene un módulo SampleTests que contiene una clase derivada de TestCase SampleTestCase con tres métodos de test (test_one(), test_two(), y test_three()), el especificador SampleTests.SampleTestCase' haría que este método devolviera una suite que ejecutara los tres métodos de prueba. El uso del especificador SampleTests.SampleTestCase.test_two' provocaría que este método devolviera una suite de tests que ejecutaría sólo el método de test test_two(). El especificador puede referirse a los módulos y paquetes que no han sido importados; serán importados como un efecto secundario.

El método opcionalmente resuelve name relativo al module dado.

Distinto en la versión 3.5: Si un ImportError o AttributeError ocurre mientras atraviesa name entonces se devolverá un test sintético que lanza ese error cuando se ejecuta. Estos errores están incluidos en los errores acumulados por self.errors.

loadTestsFromNames(names, module=None)

Similar a loadTestsFromName(), pero toma una secuencia de nombres en lugar de un solo nombre. El valor de retorno es una suite de tests que soporta todos los test definidos para cada nombre.

getTestCaseNames(testCaseClass)

Devuelve una secuencia ordenada de nombres de métodos encontrados dentro de testCaseClass; esta debería ser una subclase de TestCase.

discover(start_dir, pattern='test*.py', top_level_dir=None)

Encuentra todos los módulos de prueba recurriendo a subdirectorios del directorio de inicio especificado, y retorna un objeto de TestSuite que los contenga. Sólo se cargarán los archivos de test que coincidan con el pattern. (Utilizando la coincidencia de patrones de estilo de shell.) Sólo se cargarán los nombres de los módulos que sean importables (es decir, que sean identificadores Python válidos).

Todos los módulos de test deben ser importables desde el nivel superior del proyecto. Si el directorio de inicio no es el directorio de nivel superior, entonces el directorio de nivel superior debe ser especificado por separado.

Si la importación de un módulo falla, por ejemplo debido a un error de sintaxis, entonces esto se registrará como un error único y el descubrimiento continuará. Si el fallo en la importación se debe a que SkipTest se ha lanzado, se registrará como un salto en lugar de un error.

Si se encuentra un paquete (un directorio que contiene un archivo llamado __init__.py), se comprobará si el paquete tiene una función load_tests. Si existe, entonces se invocará package.load_tests(loader, tests, pattern). Test discovery se encarga de asegurar que un paquete sólo se comprueba una vez durante una invocación, incluso si la propia función load_tests llama a loader.discover.

Si load_tests existe, entonces el descubrimiento no recurre en el paquete, load_tests es responsable de cargar todos los tests en el paquete.

El patrón no se almacena deliberadamente como atributo cargador para que los paquetes puedan continuar descubriéndose a sí mismos. top_level_dir se almacena de forma que load_tests no necesita pasar este argumento a loader.discover().

start_dir puede ser un nombre de módulo punteado así como un directorio.

Nuevo en la versión 3.2.

Distinto en la versión 3.4: Los módulos que lanzan SkipTest en la importación se registran como saltos, no como errores.

Distinto en la versión 3.4: start_dir puede ser un paquete de espacios de nombres.

Distinto en la versión 3.4: Las rutas se ordenan antes de ser importadas para que el orden de ejecución sea el mismo, incluso si el orden del sistema de archivos subyacente no depende del nombre del archivo.

Distinto en la versión 3.5: Los paquetes encontrados son ahora comprobados para load_tests sin importar si su ruta coincide con el pattern, porque es imposible que el nombre de un paquete coincida con el patrón por defecto.

Los siguientes atributos de un TestLoader pueden ser configurados ya sea por subclasificación o asignación en una instancia:

testMethodPrefix

Cadena que da el prefijo de los nombres de métodos que serán interpretados como métodos de test. El valor por defecto es 'test'.

Esto afecta a getTestCaseNames() y a todos los métodos loadTestsFrom*() .

sortTestMethodsUsing

Función que se utiliza para comparar los nombres de los métodos al clasificarlos en getTestCaseNames() y todos los métodos loadTestsFrom*().

suiteClass

Objeto invocable que construye un conjunto de pruebas a partir de una lista de pruebas. No se necesitan métodos en el objeto resultante. El valor por defecto es la clase TestSuite.

Esto afecta a todos los métodos loadTestsFrom*().

testNamePatterns

List of Unix shell-style wildcard test name patterns that test methods have to match to be included in test suites (see -k option).

If this attribute is not None (the default), all test methods to be included in test suites must match one of the patterns in this list. Note that matches are always performed using fnmatch.fnmatchcase(), so unlike patterns passed to the -k option, simple substring patterns will have to be converted using * wildcards.

Esto afecta a todos los métodos loadTestsFrom*().

Nuevo en la versión 3.7.

class unittest.TestResult

Esta clase se utiliza para recopilar información sobre qué tests han tenido éxito y cuáles han fracasado.

Un objeto TestResult almacena los resultados de una serie de pruebas. Las clases TestCase y TestSuite aseguran que los resultados se registren correctamente; los autores de los tests no tienen que preocuparse de registrar el resultado de las mismas.

Los marcos de pruebas construidos sobre unittest pueden querer acceder al objeto TestResult generado por la ejecución de un conjunto de tests con fines de reporte; una instancia TestResult es devuelta por el método TestRunner.run() para este propósito.

Las instancias de TestResult tienen los siguientes atributos que serán de interés cuando se inspeccionen los resultados de la ejecución de un conjunto de tests:

errors

Una lista que contiene 2 tuplas de instancias TestCase y cadenas con formato de tracebacks. Cada tupla representa una prueba que lanzó una excepción inesperada.

failures

Una lista que contiene 2 tuplas de instancias TestCase y cadenas con formato de traceback. Cada tupla representa un test en el que un fallo fue explícitamente señalado usando los métodos TestCase.assert*().

skipped

Una lista que contiene 2 tuplas de instancias de TestCase y cadenas que contienen la razón para saltarse el test.

Nuevo en la versión 3.1.

expectedFailures

Una lista que contiene 2 tuplas de instancias TestCase y cadenas con formato de traceback. Cada tupla representa un fallo esperado del caso de test.

unexpectedSuccesses

Una lista que contiene instancias de TestCase que fueron marcadas como fracasos esperados, pero tuvieron éxito.

shouldStop

Puesto en True cuando la ejecución de los tests se detenga por stop().

testsRun

El número total de tests realizados hasta ahora.

buffer

Si se ajusta a true, sys.stdout y sys.stderr serán almacenados entre startTest() y stopTest() siendo llamados. La salida recolectada sólo tendrá eco en el verdadero sys.stdout y sys.stderr si la prueba falla o se equivoca. Cualquier salida también se adjunta al mensaje de fallo / error.

Nuevo en la versión 3.2.

failfast

Si se ajusta a true stop() se llamará al primer fallo o error, deteniendo la ejecución de la prueba.

Nuevo en la versión 3.2.

tb_locals

Si se ajusta a true entonces las variables locales se mostrarán en los tracebacks.

Nuevo en la versión 3.5.

wasSuccessful()

Devuelve True si todas las pruebas realizadas hasta ahora han pasado, de lo contrario devuelve False.

Distinto en la versión 3.4: Devuelve False si hubo algún unexpectedSuccesses de las pruebas marcadas con el decorador expectedFailure().

stop()

Este método puede ser llamado para señalar que el conjunto de pruebas que se están ejecutando debe ser abortado poniendo el atributo shouldStop en True. TestRunner los objetos deben respetar esta bandera y regresar sin ejecutar ninguna prueba adicional.

Por ejemplo, esta característica es utilizada por la clase TextTestRunner para detener el marco de pruebas cuando el usuario señala una interrupción desde el teclado. Las herramientas interactivas que proporcionan implementaciones de TestRunner pueden usar esto de manera similar.

Los siguientes métodos de la clase TestResult se utilizan para mantener las estructuras de datos internos, y pueden ampliarse en subclases para apoyar los requisitos de información adicionales. Esto es particularmente útil para construir herramientas que apoyen la presentación de informes interactivos mientras se ejecutan las pruebas.

startTest(test)

Llamado cuando el caso de prueba test está a punto de ser ejecutado.

stopTest(test)

Llamado después de que el caso de prueba prueba haya sido ejecutado, independientemente del resultado.

startTestRun()

Llamado una vez antes de que se ejecute cualquier prueba.

Nuevo en la versión 3.1.

stopTestRun()

Llamado una vez después de que se ejecuten todas las pruebas.

Nuevo en la versión 3.1.

addError(test, err)

Llamado cuando el caso de prueba test plantea una excepción inesperada. err es una tupla de la forma devuelta por sys.exc_info(): (type, value, traceback).

La implementación por defecto añade una tupla (test, formatted_err) al atributo errors de la instancia, donde formatted_err es una traza formateada derivada de err.

addFailure(test, err)

Llamado cuando el caso de prueba test señala un fallo. err es una tupla de la forma devuelta por sys.exc_info(): (type, value, traceback).

La implementación por defecto añade una tupla (test, formatted_err) al atributo failures de la instancia, donde formatted_err es una traza formateada derivada de err.

addSuccess(test)

Llamado cuando el caso de prueba test tenga éxito.

La implementación por defecto no hace nada.

addSkip(test, reason)

Llamado cuando se salta el caso de prueba test. reason es la razón que la prueba dio para saltarse.

La implementación por defecto añade una tupla (test, reason) al atributo skipped de la instancia.

addExpectedFailure(test, err)

Llamó cuando el caso de prueba test falla, pero fue marcado con el decorador expectedFailure().

La implementación por defecto añade una tupla (test, formatted_err) al atributo expectedFailures de la instancia, donde formatted_err es una traza formateada derivada de err.

addUnexpectedSuccess(test)

Llamó cuando el caso de prueba test se marcó con el decorador expectedFailure(), pero tuvo éxito.

La implementación por defecto añade la prueba al atributo unexpectedSuccesses de la instancia.

addSubTest(test, subtest, outcome)

Llamado cuando termina una subtest. test es el caso de prueba correspondiente al método de test. subtest es una instancia personalizada TestCase que describe el test.

Si outcome es None, el subtest tuvo éxito. De lo contrario, falló con una excepción en la que outcome es una tupla de la forma devuelta por sys.exc_info(): (type, value, traceback).

La implementación por defecto no hace nada cuando el resultado es un éxito, y registra los fallos del subtest como fallos normales.

Nuevo en la versión 3.4.

class unittest.TextTestResult(stream, descriptions, verbosity)

Una implementación concreta de TestResult utilizado por el TextTestRunner.

Nuevo en la versión 3.2: Esta clase se llamaba anteriormente _TextTestResult. El antiguo nombre todavía existe como un alias pero está obsoleto.

unittest.defaultTestLoader

Instancia de la clase TestLoader destinada a ser compartida. Si no es necesario personalizar la clase TestLoader, esta instancia puede utilizarse en lugar de crear repetidamente nuevas instancias.

class unittest.TextTestRunner(stream=None, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None, *, tb_locals=False)

Una implementación básica del test runner que produce resultados en una corriente. Si stream es None, el valor por defecto, sys.stderr se utiliza como flujo de salida. Esta clase tiene unos pocos parámetros configurables, pero es esencialmente muy simple. Las aplicaciones gráficas que ejecutan las suites de prueba deben proporcionar implementaciones alternativas. Tales implementaciones deberían aceptar **kwargs como interfaz para construir los cambios de los corredores cuando se añaden características a unittest.

Por defecto este runner muestra DeprecationWarning, PendingDeprecationWarning, ResourceWarning y ImportWarning aunque estén ignorados por defecto. Las advertencias de deprecación causadas por métodos deprecated unittest también tienen un caso especial y, cuando los filtros de advertencia están 'default' o 'always', aparecerán sólo una vez por módulo, para evitar demasiados mensajes de advertencia. Este comportamiento puede ser anulado usando las opciones -Wd o -Wa de Python (ver Control de advertencias) y dejando warnings a None.

Distinto en la versión 3.2: Añadió el argumento warnings.

Distinto en la versión 3.2: El flujo por defecto está configurado como sys.stderr en tiempo de instanciación en lugar de tiempo de importación.

Distinto en la versión 3.5: Añadido el parámetro tb_locals.

_makeResult()

Este método devuelve la instancia de TestResult usada por run(). No está destinado a ser llamado directamente, pero puede ser anulado en subclases para proporcionar un TestResult personalizado.

_makeResult() instanciando la clase o el pasaje llamado en el constructor TextTestRunner como el argumento de resultclass. Por defecto es TextTestResult si no se proporciona ninguna resultclass. La clase de resultado se instanciará con los siguientes argumentos:

stream, descriptions, verbosity

run(test)

Este método es la principal interfaz pública del TextTestRunner. Este método toma una instancia TestSuite o TestCase. Se crea una TestResult llamando a _makeResult() y se ejecuta(n) la(s) prueba(s) y se imprimen los resultados a stdout.

unittest.main(module='__main__', defaultTest=None, argv=None, testRunner=None, testLoader=unittest.defaultTestLoader, exit=True, verbosity=1, failfast=None, catchbreak=None, buffer=None, warnings=None)

Un programa de línea de comandos que carga un conjunto de pruebas de módulo y las ejecuta; esto es principalmente para hacer los módulos de prueba convenientemente ejecutables. El uso más simple de esta función es incluir la siguiente línea al final de un guión de prueba:

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

Puedes hacer pruebas con información más detallada pasando el argumento de la verbosity:

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

El argumento defaultTest es el nombre de una prueba única o un iterable de nombres de pruebas a ejecutar si no se especifican nombres de pruebas a través de argv. Si no se especifica o Ninguno y no se proporcionan nombres de pruebas vía argv, se ejecutan todas las pruebas encontradas en modulo.

El argumento argv puede ser una lista de opciones pasadas al programa, siendo el primer elemento el nombre del programa. Si no se especifica o Ninguno, se utilizan los valores de sys.argv.

El argumento testRunner puede ser una clase de corredor de prueba o una instancia ya creada de él. Por defecto main llama sys.exit() con un código de salida que indica el éxito o el fracaso de la ejecución de las pruebas.

El argumento testLoader tiene que ser una instancia TestLoader, y por defecto defaultTestLoader.

main apoya el uso del intérprete interactivo pasando el argumento exit=False. Esto muestra el resultado en la salida estándar sin llamar a sys.exit():

>>> from unittest import main
>>> main(module='test_module', exit=False)

Los parámetros failfast, catchbreak y buffer tienen el mismo efecto que las command-line options del mismo nombre.

El argumento warnings especifica el filtro de aviso que debe ser usado mientras se realizan los tests. Si no se especifica, permanecerá como None si se pasa una opción -W a python (ver Warning control), de lo contrario se establecerá como ’default’.

Invocar main en realidad devuelve una instancia de la clase TestProgram. Esto almacena el resultado de las pruebas ejecutadas como el atributo result.

Distinto en la versión 3.1: El parámetro exit fue añadido.

Distinto en la versión 3.2: Los parámetros verbosity, failfast, catchbreak, buffer y warnings fueron añadidos.

Distinto en la versión 3.4: El parámetro defaultTest fue cambiado para aceptar también un iterable de nombres de pruebas.

load_tests protocolo

Nuevo en la versión 3.2.

Los módulos o paquetes pueden personalizar la forma en que se cargan las pruebas a partir de ellos durante las ejecuciones de prueba normales o el descubrimiento de pruebas mediante la implementación de una función llamada load_tests.

Si un módulo de tests define load_tests será llamado por TestLoader.loadTestsFromModule() con los siguientes argumentos:

load_tests(loader, standard_tests, pattern)

donde pattern se pasa directamente desde loadTestsFromModule. Por defecto es None.

Debe retornar una TestSuite.

loader es la instancia de TestLoader haciendo la carga. standard_tests son los tests que se cargarían por defecto desde el módulo. Es común que los módulos de test sólo quieran añadir o quitar tests del conjunto de tests estándar. El tercer argumento se usa cuando se cargan paquetes como parte del descubrimiento de tests.

Una típica función de load_tests que carga pruebas de un conjunto específico de TestCase`class:`TestCase puede ser como:

test_cases = (TestCase1, TestCase2, TestCase3)

def load_tests(loader, tests, pattern):
    suite = TestSuite()
    for test_class in test_cases:
        tests = loader.loadTestsFromTestCase(test_class)
        suite.addTests(tests)
    return suite

Si discovery se inicia en un directorio que contiene un paquete, ya sea desde la línea de comandos o llamando a TestLoader.discover(), entonces el paquete __init__.py se comprobará por load_tests. Si esa función no existe, discover se reincorporará al paquete como si fuera un directorio más. De lo contrario, el descubrimiento de los tests del paquete se dejará en load_tests que se llama con los siguientes argumentos:

load_tests(loader, standard_tests, pattern)

Esto debería devolver un TestSuite que represente todas las pruebas del paquete. (test_estándar sólo contendrá las pruebas recogidas de __init__.py.)

Debido a que el patrón se pasa a load_tests el paquete es libre de continuar (y potencialmente modificar) el descubrimiento de pruebas. Una función de “no hace nada” load_test para un paquete de pruebas se vería como:

def load_tests(loader, standard_tests, pattern):
    # top level directory cached on loader instance
    this_dir = os.path.dirname(__file__)
    package_tests = loader.discover(start_dir=this_dir, pattern=pattern)
    standard_tests.addTests(package_tests)
    return standard_tests

Distinto en la versión 3.5: Discovery ya no comprueba si los nombres de los paquetes coinciden con el patrón debido a la imposibilidad de que los nombres de los paquetes coincidan con el patrón por defecto.

Instalaciones para clases y módulos

Los accesorios de nivel de clase y módulo se implementan en TestSuite. Cuando el conjunto de pruebas se encuentra con una prueba de una nueva clase entonces se llama tearDownClass() de la clase anterior (si existe), seguido de setUpClass() de la nueva clase.

Del mismo modo, si una prueba es de un módulo diferente de la prueba anterior, entonces se ejecuta DesmontarMódulo del módulo anterior, seguido de DesmontarMódulo del nuevo módulo.

Después de todas las pruebas, se ejecutan los últimos tearDownClass y tearDownModule.

Tenga en cuenta que los accesorios compartidos no juegan bien con las características [potenciales] como la paralelización de la prueba y rompen el aislamiento de la prueba. Deben ser usados con cuidado.

El orden por defecto de las pruebas creadas por los cargadores de pruebas unitarias es agrupar todas las pruebas de los mismos módulos y clases. Esto llevará a que setUpClass / setUpModule (etc) sea llamado exactamente una vez por clase y módulo. Si se aleatoriza el orden, de manera que las pruebas de diferentes módulos y clases sean adyacentes entre sí, entonces estas funciones compartidas de fixture pueden ser llamadas varias veces en una sola ejecución de prueba.

Los accesorios compartidos no están pensados para trabajar con suites con pedidos no estándar. Todavía existe una BaseTestSuite para los marcos de trabajo que no quieren soportar accesorios compartidos.

Si hay alguna excepción planteada durante una de las funciones compartidas del aparato, la prueba se notifica como un error. Debido a que no hay una instancia de prueba correspondiente, se crea un objeto _ErrorHolder (que tiene la misma interfaz que un TestCase) para representar el error. Si sólo estás usando el standard unittest test runner entonces este detalle no importa, pero si eres un autor de marcos de trabajo puede ser relevante.

setUpClass y tearDownClass

Estos deben ser implementados como métodos de clase:

import unittest

class Test(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls._connection = createExpensiveConnectionObject()

    @classmethod
    def tearDownClass(cls):
        cls._connection.destroy()

Si quieres que se invoque a SetUpClass y BreakdownClass en clases base, debes llamarlos tú mismo. Las implementaciones en TestCase están vacías.

Si se lanza una excepción durante una setUpClass, entonces los tests de la clase no se ejecutan y la tearDownClass no se ejecuta. Las clases que se salten no tendrán setUpClass o tearDownClass. Si la excepción es una SkipTest entonces la clase será reportada como salteada en lugar de como un error.

setUpModule y tearDownModule

Estos deben ser implementados como funciones:

def setUpModule():
    createConnection()

def tearDownModule():
    closeConnection()

Si se lanza una excepción en un setUpModule, entonces no se ejecutará ninguna de las pruebas del módulo y no se ejecutará el tearDownModule. Si la excepción es una SkipTest entonces el módulo será reportado como saltado en lugar de como un error.

Para agregar código de limpieza que se debe ejecutar incluso en el caso de una excepción, utilice addModuleCleanup:

unittest.addModuleCleanup(function, /, *args, **kwargs)

Añade una función que se llamará después de tearDownModule() para limpiar los recursos utilizados durante la clase de test. Las funciones se llamarán en orden inverso al orden en que se agregan (LIFO). Se llaman con cualquier argumento y palabra clave que se pase a addModuleCleanup() cuando se añadan.

Si setUpModule() falla, lo que significa que tearDownModule() no se invoca, entonces cualquier función de limpieza añadida seguirá siendo invocada.

Nuevo en la versión 3.8.

unittest.doModuleCleanups()

Esta función se llama incondicionalmente después de tearDownModule(), o después de setUpModule() si setUpModule() lanza una excepción.

It is responsible for calling all the cleanup functions added by addModuleCleanup(). If you need cleanup functions to be called prior to tearDownModule() then you can call doModuleCleanups() yourself.

doModuleCleanups() saca los métodos de la pila de funciones de limpieza uno a uno, así que se puede llamar en cualquier momento.

Nuevo en la versión 3.8.

Manejo de señales

Nuevo en la versión 3.2.

La opción -c/--catch línea de comando para unittest, junto con el parámetro catchbreak de unittest.main(), proporcionan un manejo más amigable del control-C durante una prueba. Con el comportamiento catch break habilitado, control-C permitirá que se complete la prueba que se está ejecutando actualmente, y la ejecución de la prueba terminará y reportará todos los resultados hasta ahora. Un segundo control-C lanzará una KeyboardInterrupt de la manera habitual.

El manejador de señales de manejo de control-c intenta permanecer compatible con el código o las pruebas que instalan su propio manejador signal.SIGINT . Si se llama al manejador unittest pero no es el manejador signal.SIGINT instalado, es decir, ha sido reemplazado por el sistema bajo test y delegado, entonces llama al manejador por defecto. Este será normalmente el comportamiento esperado por el código que reemplaza un manejador instalado y delega en él. Para las pruebas individuales que necesiten el manejo de control-c de unittest deshabilitado se puede usar el decorador removeHandler().

Hay algunas funciones de utilidad para que los autores de marcos de trabajo habiliten la funcionalidad de control de control-c dentro de los marcos de prueba.

unittest.installHandler()

Instala el controlador de control-c. Cuando se recibe una signal.SIGINT (normalmente en respuesta a que el usuario presione control-c) todos los resultados registrados tienen stop() llamado.

unittest.registerResult(result)

Registrar un objeto TestResult para el manejo de control-c. El registro de un resultado almacena una referencia débil a él, por lo que no evita que el resultado sea recogido por el recolector de basura.

El registro de un objeto TestResult no tiene efectos secundarios si el manejo de control-c no está habilitado, por lo que los marcos de pruebas pueden registrar incondicionalmente todos los resultados que crean independientemente de si el manejo está habilitado o no.

unittest.removeResult(result)

Elimine un resultado registrado. Una vez que un resultado ha sido eliminado, stop() ya no se llamará en ese objeto de resultado en respuesta a un control-c.

unittest.removeHandler(function=None)

Cuando se llama sin argumentos, esta función quita el gestor control-c si se ha instalado. Esta función también se puede utilizar como decorador de tests para quitar temporalmente el controlador mientras se ejecuta el test:

@unittest.removeHandler
def test_signal_handling(self):
    ...