Python unittest - opposto di assertRaises?

Voglio scrivere un test per stabilire che non viene sollevata un'eccezione in una determinata circostanza.

È semplice verificare se viene sollevata un'eccezione ...

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

... ma come puoi fare il contrario .

Qualcosa del genere è quello che sto cercando ...

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

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

Ciao - Voglio scrivere un test per stabilire che non viene sollevata un'eccezione in una determinata circostanza.

Questo è il presupposto predefinito: non vengono sollevate eccezioni.

Se non dici altro, questo è assunto in ogni singolo test.

Non è necessario scrivere alcuna affermazione per questo.

Basta chiamare la funzione. Se genera un'eccezione, il framework di unit test contrassegnerà questo come errore. Potresti aggiungere un commento, ad esempio:

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

Sono il poster originale e ho accettato la risposta di cui sopra DGH senza averlo prima utilizzato nel codice.

Una volta che ho usato mi sono reso conto che aveva bisogno di un po 'di modifiche per fare davvero quello che mi serviva (per essere onesti con DGH ha detto "o qualcosa di simile"!).

Ho pensato che valesse la pena pubblicare il tweak qui a beneficio di altri:

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

Quello che stavo tentando di fare qui era assicurarmi che se si fosse tentato di creare un'istanza di un oggetto Applicazione con un secondo argomento di spazi, sarebbe stato sollevato pySourceAidExceptions.PathIsNotAValidOne.

Credo che l'uso del codice sopra riportato (basato pesantemente sulla risposta della DGH) lo farà.

È possibile definire assertNotRaisesriutilizzando circa il 90% dell'implementazione originale di assertRaisesnel unittestmodulo. Con questo approccio, si finisce con un assertNotRaisesmetodo che, a parte la sua condizione di fallimento inversa, si comporta in modo identicoassertRaises .

TLDR e demo live

Risulta sorprendentemente facile aggiungere un assertNotRaisesmetodo a unittest.TestCase(mi ci è voluto circa 4 volte più tempo per scrivere questa risposta come ha fatto il codice). Ecco una demo live del assertNotRaisesmetodo in azione . Proprio comeassertRaises , puoi passare un callable e discutere assertNotRaises, oppure puoi usarlo in una withdichiarazione. La demo live include casi di test che lo dimostranoassertNotRaises funziona come previsto.

Dettagli

L'implementazione di assertRaisesaunittest è abbastanza complicata, ma con un po 'di sottoclasse intelligente puoi sovrascrivere e invertire la sua condizione di fallimento.

assertRaisesè un metodo breve che fondamentalmente crea solo un'istanza della unittest.case._AssertRaisesContextclasse e la restituisce (vedere la sua definizione nel unittest.casemodulo). Puoi definire la tua _AssertNotRaisesContextclasse effettuando la sottoclasse _AssertRaisesContexte sovrascrivendo il suo __exit__metodo:

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 si definiscono le classi di test case facendole ereditare da TestCase. Se invece erediti da una sottoclasse 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

tutti i casi di test avranno ora il assertNotRaisesmetodo a loro disposizione.

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)) 

potrebbe essere modificato se è necessario accettare i parametri.

chiama come

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

Ho trovato utile patch di scimmia unittestcome segue:

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

Questo chiarisce l'intento durante il test per l'assenza di un'eccezione:

self.assertMayRaise(None, does_not_raise)

Questo semplifica anche i test in un ciclo, che spesso mi ritrovo a fare:

# 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))

Se si passa una classe di eccezione a assertRaises(), viene fornito un gestore di contesto. Questo può migliorare la leggibilità dei tuoi test:

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

Ciò consente di testare casi di errore nel codice.

In questo caso, si sta verificando che PathIsNotAValidOneviene generato quando si passano parametri non validi al costruttore dell'applicazione.

puoi provare così. try: self.assertRaises (None, function, arg1, arg2) ad eccezione di: pass se non si inserisce codice all'interno di try block lo farà tramite l'eccezione "AssertionError: None not raised" e il caso di test fallirà. Il caso di test verrà superato se inserito dentro prova a bloccare quale è il comportamento previsto.

Un modo semplice per garantire che l'oggetto venga inizializzato senza errori è testare l'istanza del tipo di oggetto.

Ecco un esempio:

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