Python | Pruebas de condiciones excepcionales en pruebas unitarias

Este artículo tiene como objetivo escribir una prueba unitaria que pruebe limpiamente si se genera una excepción. Para probar las excepciones, se usa el método assertRaises() .

Código n. ° 1: prueba de que una función generó una excepción ValueError

import unittest
  
# A simple function to illustrate
def parse_int(s):
    return int(s)
  
class TestConversion(unittest.TestCase):
    def test_bad_int(self):
        self.assertRaises(ValueError, parse_int, 'N/A')

Código n. ° 2: se necesita probar el valor de la excepción con un enfoque diferente

import errno
  
class TestIO(unittest.TestCase):
    def test_file_not_found(self):
        try:
            f = open('/file/not/found')
        except IOError as e:
            self.assertEqual(e.errno, errno.ENOENT)
        else:
            self.fail('IOError not raised')

El assertRaises() método proporciona una manera conveniente de probar la presencia de una excepción. Un error común es escribir pruebas que intentan hacer cosas manualmente con excepciones por su cuenta.

Código #3: Ejemplo

class TestConversion(unittest.TestCase):
    def test_bad_int(self):
        try:
            r = parse_int('N/A')
        except ValueError as e:
            self.assertEqual(type(e), ValueError)

El problema con estos enfoques es que es fácil olvidarse de los casos extremos, como cuando no se genera ninguna excepción. Para hacer eso, se debe agregar una verificación adicional para esa situación, como se muestra en el código a continuación.

Código #4:

class TestConversion(unittest.TestCase):
    def test_bad_int(self):
        try:
            r = parse_int('N/A')
        except ValueError as e:
            self.assertEqual(type(e), ValueError)
        else:
            self.fail('ValueError not raised')

El assertRaises()método simplemente se ocupa de estos detalles, por lo que se prefiere su uso. La única limitación de assertRaises()es que no proporciona un medio para probar el valor del objeto de excepción que se crea.
Para hacer eso, tiene que ser probado manualmente. En algún lugar entre estos dos extremos, se puede usar el método assertRaisesRegex() y permite probar una excepción y realizar una coincidencia de expresión regular con la representación de string de la excepción al mismo tiempo.

Código #5:

class TestConversion(unittest.TestCase):
    def test_bad_int(self):
        self.assertRaisesRegex(
                ValueError, 'invalid literal .*', 
                parse_int, 'N/A')

Un hecho poco conocido acerca de assertRaises()y assertRaisesRegex()es que también se pueden usar como administradores de contexto.

Código #6:

class TestConversion(unittest.TestCase):
    def test_bad_int(self):
        with self.assertRaisesRegex(ValueError, 'invalid literal .*'):
            r = parse_int('N/A')

Este formulario puede ser útil si la prueba implica varios pasos (p. ej., configuración) además de simplemente ejecutar un invocable.