Python unittest - Gegenteil von assertRaises?

Ich möchte einen Test schreiben, um festzustellen, dass eine Ausnahme unter bestimmten Umständen nicht ausgelöst wird.

Es ist einfach zu testen, ob eine Ausnahme ausgelöst wird ...

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

... aber wie kann man das Gegenteil tun .

So etwas wie das, wonach ich suche ...

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

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

Hallo, ich möchte einen Test schreiben, um festzustellen, dass unter bestimmten Umständen keine Ausnahme ausgelöst wird.

Dies ist die Standardannahme - Ausnahmen werden nicht ausgelöst.

Wenn Sie nichts anderes sagen, wird dies in jedem einzelnen Test vorausgesetzt.

Sie müssen dafür keine Behauptung schreiben.

Rufen Sie einfach die Funktion auf. Wenn eine Ausnahme ausgelöst wird, kennzeichnet das Unit-Test-Framework dies als Fehler. Möglicherweise möchten Sie einen Kommentar hinzufügen, z.

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

Ich bin das Originalplakat und habe die obige Antwort von DGH akzeptiert, ohne sie zuvor im Code verwendet zu haben.

Als ich es benutzte, wurde mir klar, dass es ein wenig optimiert werden musste, um das zu tun, wofür ich es brauchte (um der DGH gegenüber fair zu sein, sagte er / sie "oder ähnliches"!).

Ich dachte, es lohnt sich, den Tweak hier zum Nutzen anderer zu veröffentlichen:

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

Ich habe hier versucht sicherzustellen, dass pySourceAidExceptions.PathIsNotAValidOne ausgelöst wird, wenn versucht wird, ein Anwendungsobjekt mit einem zweiten Argument von Leerzeichen zu instanziieren.

Ich glaube, dass die Verwendung des obigen Codes (der stark von der Antwort der DGH abhängt) dies tun wird.

Sie können definieren, assertNotRaisesindem Sie etwa 90% der ursprünglichen Implementierung von assertRaisesim unittestModul wiederverwenden . Mit diesem Ansatz erhalten Sie eineassertNotRaises Methode, die sich, abgesehen von ihrem umgekehrten Fehlerzustand, identisch verhält assertRaises.

TLDR und Live-Demo

Es stellt sich als überraschend einfach heraus, eine assertNotRaisesMethode hinzuzufügen unittest.TestCase(ich habe ungefähr viermal so lange gebraucht, um diese Antwort zu schreiben wie den Code). Hier ist eine Live-Demo der assertNotRaisesMethode in Aktion . Genau wieassertRaises können Sie entweder eine aufrufbare und args passieren zu assertNotRaises, oder Sie können es in einer verwenden withAussage. Die Live-Demo enthält Testfälle, die dies demonstrierenassertNotRaises wie beabsichtigt funktioniert.

Einzelheiten

Die Umsetzung von assertRaisesinunittest ist ziemlich kompliziert, aber mit ein wenig cleverer Unterklasse können Sie den Fehlerzustand überschreiben und umkehren.

assertRaisesist eine kurze Methode, die im Grunde nur eine Instanz der unittest.case._AssertRaisesContextKlasse erstellt und zurückgibt (siehe Definition im unittest.caseModul). Sie können Ihre eigene _AssertNotRaisesContextKlasse definieren, indem Sie _AssertRaisesContextihre __exit__Methode unterordnen und überschreiben :

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

Normalerweise definieren Sie Testfallklassen, indem Sie sie erben lassen TestCase. Wenn Sie stattdessen von einer Unterklasse erben 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

Allen Ihren Testfällen steht jetzt die assertNotRaisesMethode zur Verfügung.

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

kann geändert werden, wenn Sie Parameter akzeptieren müssen.

Anruf wie

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

Ich fand es nützlich, Affen unittestwie folgt zu patchen :

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

Dies verdeutlicht die Absicht beim Testen auf das Fehlen einer Ausnahme:

self.assertMayRaise(None, does_not_raise)

Dies vereinfacht auch das Testen in einer Schleife, was ich oft mache:

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

Wenn Sie eine Ausnahmeklasse übergeben, assertRaises()wird ein Kontextmanager bereitgestellt. Dies kann die Lesbarkeit Ihrer Tests verbessern:

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

Auf diese Weise können Sie Fehlerfälle in Ihrem Code testen.

In diesem Fall testen Sie das PathIsNotAValidOnewird ausgelöst, wenn Sie ungültige Parameter an den Anwendungskonstruktor übergeben.

Sie können so versuchen. try: self.assertRaises (None, function, arg1, arg2) außer: pass Wenn Sie keinen Code in den try-Block einfügen, wird die Ausnahme 'AssertionError: None not ausgelöst "und der Testfall wird fehlgeschlagen. Der Testfall wird bestanden Wenn es in den Try-Block gestellt wird, ist das erwartete Verhalten.

Eine einfache Möglichkeit, um sicherzustellen, dass das Objekt fehlerfrei initialisiert wird, besteht darin, die Typinstanz des Objekts zu testen.

Hier ist ein Beispiel :

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