assertRaises falla, incluso el invocable aumenta la excepción requerida (python, unitest)

Question

Tengo la siguiente comprobación de código de prueba para una excepción alzar en una función. Espero que pase la prueba, pero en su lugar se indica una falla. Aquí está el código de prueba:

import unittest 

# define a user-defined exception 
class MyException(Exception): 
    def __str__(self): 
     return repr("ERROR: Just raised my exception!") 

# this is my main class with a method raising this exception 
class MyMainObject(object): 

    def func(self): 
     raise MyException() 

# the test class 
class TestConfig(unittest.TestCase): 

    def test_1(self): 

     other = MyMainObject() 
     self.assertRaises(MyException, other.func()) 

# calling the test 
if __name__ == '__main__':  
    unittest.main() 

Cuando other.func() se llama en la sentencia assert, MyException se eleva (se puede comprobar fácilmente). Por lo tanto, la prueba assertRaises debe pasar la prueba, como other.func() failes con MyException, PERO:

.... 
MyException: 'ERROR: Just raised my exception!' 

---------------------------------------------------------------------- 
Ran 1 test in 0.001s 

FAILED (errors=1) 

no veo algo malo, por lo que agradecería alguna entrada en este problema.

Answer 1

assertRaises llama a la función para usted. Al llamarlo usted mismo, la excepción se plantea antes deassertRaises puede probarlo.

cambiar el código para:

self.assertRaises(MyException, other.func) 

y que funcionará correctamente. Como alternativa, puede utilizar assertRaises como un gestor de contexto (Python 2.7 en adelante):

with self.assertRaises(MyException): 
    other.func() 

Usando assertRaises como un gestor de contexto tiene la ventaja añadida de que ahora puede recuperar la instancia de excepción y realizar más pruebas en él:

with self.assertRaises(MyException) as raises_cm: 
    other.func() 

exception = raises_cm.exception 
self.assertEqual(exception.args, ('foo', 'bar')) 

Answer 2

Debido a las reglas de los idiomas, los argumentos se evalúan antes de que se ingrese el código de la función llamada (y eso generalmente es algo bueno). Por lo tanto, assertRaises no puede detectar excepciones que ocurren durante la evaluación de argumentos. La solución alternativa (en más de una API) es que pase un llamable a métodos como assertRaises, para que puedan evaluarlo en un lugar que puedan controlar y donde puedan detectar excepciones. Si todo el argumento es una llamada a un método, la magia de los métodos encuadernados le permite indicar esto bastante elegante, sin lambda o tamaña estupidez:

self.assertRaises(MyException, other.func) # <- note, no parentheses after func