Prueba unitaria de Python: ¿opuesto a afirmar elevaciones?

Quiero escribir una prueba para establecer que una excepción no se genera en una circunstancia determinada.

Es sencillo a prueba si una excepción se levantó ...

sInvalidPath=AlwaysSuppliesAnInvalidPath()
self.assertRaises(PathIsNotAValidOne, MyObject, sInvalidPath) 

... pero cómo puedes hacer lo contrario .

Algo como esto, lo que busco ...

sValidPath=AlwaysSuppliesAValidPath()
self.assertNotRaises(PathIsNotAValidOne, MyObject, sValidPath) 

def run_test(self):
    try:
        myFunc()
    except ExceptionType:
        self.fail("myFunc() raised ExceptionType unexpectedly!")

Hola, quiero escribir una prueba para establecer que no se genera una excepción en una circunstancia determinada.

Esa es la suposición predeterminada: no se generan excepciones.

Si no dice nada más, eso se supone en cada prueba.

No tienes que escribir ninguna afirmación para eso.

Solo llama a la función. Si genera una excepción, el marco de prueba de la unidad marcará esto como un error. Es posible que desee agregar un comentario, por ejemplo:

sValidPath=AlwaysSuppliesAValidPath()
# Check PathIsNotAValidOne not thrown
MyObject(sValidPath)

Soy el póster original y acepté la respuesta anterior de DGH sin haberla usado primero en el código.

Una vez que lo utilicé, me di cuenta de que necesitaba un pequeño ajuste para realmente hacer lo que tenía que hacer (para ser justos con DGH, ¡él / ella dijo "o algo similar"!).

Pensé que valía la pena publicar el ajuste aquí para beneficio de otros:

    try:
        a = Application("abcdef", "")
    except pySourceAidExceptions.PathIsNotAValidOne:
        pass
    except:
        self.assertTrue(False)

Lo que intentaba hacer aquí era asegurarme de que si se intentaba crear una instancia de un objeto Aplicación con un segundo argumento de espacios, se generaría pySourceAidExceptions.PathIsNotAValidOne.

Creo que usar el código anterior (basado en gran medida en la respuesta de DGH) hará eso.

Puede definir assertNotRaisesreutilizando aproximadamente el 90% de la implementación original de assertRaisesen el unittestmódulo. Con este enfoque, terminas con un assertNotRaisesmétodo que, aparte de su condición de falla inversa, se comporta de manera idéntica assertRaises.

TLDR y demostración en vivo

Resulta sorprendentemente fácil agregarle un assertNotRaisesmétodo unittest.TestCase(me tomó alrededor de 4 veces más tiempo escribir esta respuesta que el código). Aquí hay una demostración en vivo del assertNotRaisesmétodo en acción . Al igual queassertRaises , puede pasar un invocable y argumentos a assertNotRaises, o puede usarlo en una withdeclaración. La demostración en vivo incluye una prueba de casos que demuestra que assertNotRaisesfunciona según lo previsto.

Detalles

La implementación de assertRaisesin unittestes bastante complicada, pero con un poco de subclases inteligentes puede anular e invertir su condición de falla.

assertRaiseses un método corto que básicamente solo crea una instancia de la unittest.case._AssertRaisesContextclase y la devuelve (consulte su definición en el unittest.casemódulo). Puede definir su propia _AssertNotRaisesContextclase subclasificando _AssertRaisesContexty anulando su __exit__método:

import traceback
from unittest.case import _AssertRaisesContext

class _AssertNotRaisesContext(_AssertRaisesContext):
    def __exit__(self, exc_type, exc_value, tb):
        if exc_type is not None:
            self.exception = exc_value.with_traceback(None)

            try:
                exc_name = self.expected.__name__
            except AttributeError:
                exc_name = str(self.expected)

            if self.obj_name:
                self._raiseFailure("{} raised by {}".format(exc_name,
                    self.obj_name))
            else:
                self._raiseFailure("{} raised".format(exc_name))

        else:
            traceback.clear_frames(tb)

        return True

Normalmente define clases de casos de prueba haciendo que hereden de TestCase. Si en cambio heredas de una subclase MyTestCase:

class MyTestCase(unittest.TestCase):
    def assertNotRaises(self, expected_exception, *args, **kwargs):
        context = _AssertNotRaisesContext(expected_exception, self)
        try:
            return context.handle('assertNotRaises', args, kwargs)
        finally:
            context = None

Todos sus casos de prueba ahora tendrán el assertNotRaisesmétodo disponible para ellos.

def _assertNotRaises(self, exception, obj, attr):                                                                                                                              
     try:                                                                                                                                                                       
         result = getattr(obj, attr)                                                                                                                                            
         if hasattr(result, '__call__'):                                                                                                                                        
             result()                                                                                                                                                           
     except Exception as e:                                                                                                                                                     
         if isinstance(e, exception):                                                                                                                                           
            raise AssertionError('{}.{} raises {}.'.format(obj, attr, exception)) 

podría modificarse si necesita aceptar parámetros.

llamar como

self._assertNotRaises(IndexError, array, 'sort')

Lo he encontrado útil para parchear mono de la unittestsiguiente manera:

def assertMayRaise(self, exception, expr):
  if exception is None:
    try:
      expr()
    except:
      info = sys.exc_info()
      self.fail('%s raised' % repr(info[0]))
  else:
    self.assertRaises(exception, expr)

unittest.TestCase.assertMayRaise = assertMayRaise

Esto aclara la intención al probar la ausencia de una excepción:

self.assertMayRaise(None, does_not_raise)

Esto también simplifica las pruebas en un bucle, que a menudo me encuentro haciendo:

# ValueError is raised only for op(x,x), op(y,y) and op(z,z).
for i,(a,b) in enumerate(itertools.product([x,y,z], [x,y,z])):
  self.assertMayRaise(None if i%4 else ValueError, lambda: op(a, b))

Si pasa una clase de excepción a assertRaises(), se proporciona un administrador de contexto. Esto puede mejorar la legibilidad de sus pruebas:

# raise exception if Application created with bad data
with self.assertRaises(pySourceAidExceptions.PathIsNotAValidOne):
    application = Application("abcdef", "")

Esto le permite probar casos de error en su código.

En este caso, está probando que PathIsNotAValidOnese genera cuando pasa parámetros no válidos al constructor de la aplicación.

puedes intentarlo así. try: self.assertRaises (None, function, arg1, arg2) excepto: pase si no coloca el código dentro del bloque try, a través de la excepción 'AssertionError: None not raised "y el caso de prueba fallará. El caso de prueba se pasará si se coloca dentro del bloque try, que es el comportamiento esperado.

Una forma directa de garantizar que el objeto se inicialice sin ningún error es probar la instancia de tipo del objeto.

Aquí hay un ejemplo :

p = SomeClass(param1=_param1_value)
self.assertTrue(isinstance(p, SomeClass))