Python unittest - Gegenteil von assertRaises?

Question

Ich möchte einen Test schreiben, um festzustellen, dass eine Exception in einer bestimmten Situation nicht ausgelöst wird.

Es ist ganz einfach zu testen, ob eine Exception ist angehoben ...

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

... aber wie können Sie die gegenüber .

Ich suche so etwas wie das hier ...

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

Answer 1

Ich habe es als nützlich empfunden, die unittest wie folgt:

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 bei der Prüfung auf das Nichtvorhandensein einer Ausnahme:

self.assertMayRaise(None, does_not_raise)

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

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

Answer 2

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.

anrufen wie

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

Answer 3

Wenn Sie eine Exception-Klasse an assertRaises() ist ein Kontextmanager vorgesehen. Dies kann die Lesbarkeit Ihrer Tests verbessern:

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

So können Sie Fehlerfälle in Ihrem Code testen.

In diesem Fall testen Sie die PathIsNotAValidOne wird ausgelöst, wenn Sie ungültige Parameter an den Anwendungskonstruktor übergeben.

Answer 4

Sie können es auf diese Weise versuchen. versuchen: self.assertRaises(None,function,arg1, arg2) except: pass wenn Sie den Code nicht in den try-Block einfügen, wird die Ausnahme "AssertionError: None not raised " und der Testfall wird fehlschlagen. Der Testfall wird bestanden, wenn er in den try-Block gesetzt wird, was das erwartete Verhalten ist.

Answer 5

Ein einfacher Weg, um sicherzustellen, dass das Objekt ohne Fehler initialisiert wird, ist die Prüfung der Typinstanz des Objekts.

Hier ist ein Beispiel:

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