Python unittest - opposé à assertRaises?

Je veux écrire un test pour établir qu'une exception n'est pas déclenchée dans une circonstance donnée.

Il est simple de tester si une exception est levée ...

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

... mais comment pouvez-vous faire le contraire .

Quelque chose comme ça dans ce que je cherche ...

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

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

Salut - Je veux écrire un test pour établir qu'une exception n'est pas déclenchée dans une circonstance donnée.

C'est l'hypothèse par défaut - les exceptions ne sont pas levées.

Si vous ne dites rien d'autre, cela est supposé dans chaque test.

Vous n'avez pas besoin d'écrire une affirmation pour cela.

Appelez simplement la fonction. S'il déclenche une exception, le framework de tests unitaires le signalera comme une erreur. Vous pouvez ajouter un commentaire, par exemple:

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

Je suis l'affiche originale et j'ai accepté la réponse ci-dessus par DGH sans l'avoir d'abord utilisée dans le code.

Une fois que j'ai utilisé, j'ai réalisé qu'il avait besoin d'un petit ajustement pour faire ce que j'avais besoin de faire (pour être juste envers DGH, il / elle a dit "ou quelque chose de similaire"!).

J'ai pensé qu'il valait la peine de poster le tweak ici pour le bénéfice des autres:

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

Ce que j'essayais de faire ici était de garantir que si une tentative était faite pour instancier un objet Application avec un deuxième argument d'espaces, pySourceAidExceptions.PathIsNotAValidOne serait levé.

Je crois que l'utilisation du code ci-dessus (basé fortement sur la réponse de DGH) fera cela.

Vous pouvez définir assertNotRaisesen réutilisant environ 90% de l'implémentation d'origine de assertRaisesdans le unittestmodule. Avec cette approche, vous vous retrouvez avec une assertNotRaisesméthode qui, à part sa condition de défaillance inversée, se comporte de manière identique à assertRaises.

TLDR et démo en direct

Il s'avère étonnamment facile d'ajouter une assertNotRaisesméthode unittest.TestCase(il m'a fallu environ 4 fois plus de temps pour écrire cette réponse que pour le code). Voici une démonstration en direct de la assertNotRaisesméthode en action . Tout commeassertRaises , vous pouvez soit passer un appelable et des arguments à assertNotRaises, soit l'utiliser dans une withinstruction. La démo en direct comprend un cas de test qui démontre que cela assertNotRaisesfonctionne comme prévu.

Détails

L'implémentation de assertRaisesin unittestest assez compliquée, mais avec un peu de sous-classement intelligent, vous pouvez remplacer et inverser sa condition d'échec.

assertRaisesest une méthode courte qui crée simplement une instance de la unittest.case._AssertRaisesContextclasse et la renvoie (voir sa définition dans le unittest.casemodule). Vous pouvez définir votre propre _AssertNotRaisesContextclasse en sous _AssertRaisesContext-classant et en remplaçant sa __exit__méthode:

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

Normalement, vous définissez des classes de cas de test en les faisant hériter de TestCase. Si vous héritez plutôt d'une sous-classe 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

tous vos cas de test auront désormais la assertNotRaisesméthode à leur disposition.

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

pourrait être modifié si vous devez accepter des paramètres.

appeler comme

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

Je l'ai trouvé utile pour monkey-patch unittestcomme suit:

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

Cela clarifie l'intention lors du test de l'absence d'une exception:

self.assertMayRaise(None, does_not_raise)

Cela simplifie également les tests en boucle, ce que je me retrouve souvent à faire:

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

Si vous transmettez une classe Exception à assertRaises(), un gestionnaire de contexte est fourni. Cela peut améliorer la lisibilité de vos tests:

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

Cela vous permet de tester les cas d'erreur dans votre code.

Dans ce cas, vous testez le PathIsNotAValidOneest levé lorsque vous passez des paramètres non valides au constructeur d'application.

vous pouvez essayer comme ça. try: self.assertRaises (None, function, arg1, arg2) sauf: pass si vous ne mettez pas de code à l'intérieur du bloc try, il passera par l'exception "AssertionError: None not raised" et le cas de test sera échoué. Le cas de test sera réussi si mis à l'intérieur, essayez le bloc qui est le comportement attendu.

Une façon simple de s'assurer que l'objet est initialisé sans aucune erreur consiste à tester l'instance de type de l'objet.

Voici un exemple :

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