Python unittest - przeciwieństwo assertRaises?

Chcę napisać test, aby ustalić, że wyjątek nie jest zgłaszany w danych okolicznościach.

Łatwo jest sprawdzić, czy zgłoszony został wyjątek ...

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

... ale jak możesz zrobić odwrotnie .

Coś w tym stylu, o co mi chodzi ...

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

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

Cześć - Chcę napisać test, aby ustalić, że wyjątek nie jest zgłaszany w danych okolicznościach.

Takie jest domyślne założenie - wyjątki nie są zgłaszane.

Jeśli nie powiesz nic więcej, jest to zakładane w każdym teście.

Nie musisz tak naprawdę pisać żadnych twierdzeń.

Wystarczy wywołać funkcję. Jeśli zgłosi wyjątek, środowisko testów jednostkowych oznaczy to jako błąd. Możesz dodać komentarz, np .:

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

Jestem oryginalnym plakatem i przyjąłem powyższą odpowiedź przez DGH bez wcześniejszego użycia jej w kodzie.

Kiedy już skorzystałem, zdałem sobie sprawę, że trzeba było trochę ulepszyć, aby faktycznie zrobić to, czego potrzebowałem (aby być uczciwym wobec DGH, on / ona powiedział „lub coś podobnego”!).

Pomyślałem, że warto zamieścić tutaj ulepszenie z korzyścią dla innych:

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

To, co próbowałem tutaj zrobić, to upewnić się, że jeśli podjęta zostanie próba utworzenia wystąpienia obiektu aplikacji z drugim argumentem spacji, pySourceAidExceptions.PathIsNotAValidOne zostanie podniesiony.

Wierzę, że użycie powyższego kodu (opartego w dużej mierze na odpowiedzi DGH) to zrobi.

Możesz zdefiniować assertNotRaises, ponownie wykorzystując około 90% oryginalnej implementacji assertRaisesw unittestmodule. Dzięki takiemu podejściu uzyskuje się assertNotRaisesmetodę, która oprócz odwróconego stanu awarii zachowuje się identycznie assertRaises.

TLDR i demo na żywo

Okazuje się, że dodanie assertNotRaisesmetody jest zaskakująco łatwe unittest.TestCase(napisanie tej odpowiedzi zajęło mi około 4 razy więcej czasu niż kodu). Oto demo na żywo assertNotRaisesmetody w akcji . Tylko jakassertRaises , można przejść wywoływalnym i args się assertNotRaises, czy można go używać w withoświadczeniu. Demo na żywo zawiera przypadki testowe, które pokazują, że assertNotRaisesdziała zgodnie z przeznaczeniem.

Detale

Realizacja assertRaiseswunittest jest dość skomplikowana, ale przy odrobinie sprytnej podklasy można zastąpić i odwrócić jej stan awarii.

assertRaisesjest krótką metodą, która w zasadzie tworzy instancję unittest.case._AssertRaisesContextklasy i zwraca ją (patrz jej definicja w unittest.casemodule). Możesz zdefiniować własną _AssertNotRaisesContextklasę, podklasując _AssertRaisesContexti zastępując jej __exit__metodę:

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

Zwykle klasy przypadków testowych są definiowane przez dziedziczenie TestCase. Jeśli zamiast tego dziedziczysz z podklasy 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

wszystkie twoje przypadki testowe będą teraz miały assertNotRaisesdostępną dla nich metodę.

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

można zmodyfikować, jeśli musisz zaakceptować parametry.

zadzwoń jak

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

Uważam, że przydatne jest łatanie małp unittestw następujący sposób:

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

To wyjaśnia cel podczas testowania pod kątem braku wyjątku:

self.assertMayRaise(None, does_not_raise)

Upraszcza to również testowanie w pętli, co często robię:

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

Jeśli przekażesz klasę wyjątków, otrzymasz assertRaises()menedżera kontekstu. Może to poprawić czytelność twoich testów:

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

Umożliwia to testowanie przypadków błędów w kodzie.

W takim przypadku testowane PathIsNotAValidOnejest podniesienie podczas przekazywania niepoprawnych parametrów do konstruktora aplikacji.

możesz spróbować w ten sposób. try: self.assertRaises (None, function, arg1, arg2) oprócz: pass, jeśli nie umieścisz kodu w środku, spróbuj zablokować to poprzez wyjątek „AssertionError: None not failed” i przypadek testowy zakończy się niepowodzeniem. Przypadek testowy zostanie zaliczony jeśli jest w środku spróbuj bloku, którego zachowanie jest oczekiwane.

Jednym prostym sposobem na zapewnienie inicjalizacji obiektu bez żadnego błędu jest przetestowanie instancji typu obiektu.

Oto przykład :

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