# `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 `TestCase`derivada 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):
          ...