Comment gérer plusieurs asserts au sein d'un même unittest Python?

J'ai l'impression que c'est trop technique pour moi. Soit:

• utiliser deux assertions dans un cas d'essai. Si la première affirmation échoue, c'est vrai, vous ne saurez pas si la seconde affirmation a passé ou non. Mais vous allez corriger le code de toute façon, le réparer, et puis vous verrez si le deuxième affirmer passé.

• Ecrire deux tests, un pour vérifier chaque condition. Si vous craignez le code dupliqué dans les tests, mettez le gros du code dans une méthode helper qui vous appelez à partir des essais.

Je ne suis pas d'accord avec l'opinion dominante qu'on devrait écrire une méthode d'essai pour chaque affirmation. Il y a des situations où vous voulez vérifier plusieurs choses dans une méthode de test. Voici ma réponse pour savoir comment faire:

# Works with unittest in Python 2.7
class ExpectingTestCase(unittest.TestCase):
    def run(self, result=None):
        self._result = result
        self._num_expectations = 0
        super(ExpectingTestCase, self).run(result)

    def _fail(self, failure):
        try:
            raise failure
        except failure.__class__:
            self._result.addFailure(self, sys.exc_info())

    def expect_true(self, a, msg):
        if not a:
            self._fail(self.failureException(msg))
        self._num_expectations += 1

    def expect_equal(self, a, b, msg=''):
        if a != b:
            msg = '({}) Expected {} to equal {}. '.format(self._num_expectations, a, b) + msg
            self._fail(self.failureException(msg))
        self._num_expectations += 1

Et voici quelques situations où je pense que c'est utile et pas risqué:

1) Lorsque vous voulez tester le code pour différents ensembles de données. Ici, nous avons un ajout() et la fonction que je veux tester avec quelques exemples. Pour écrire 3 méthodes d'essai pour les 3 ensembles de données signifie se répéter ce qui est mauvais. Surtout si l'appel a été plus élaborées.:

class MyTest(ExpectingTestCase):
    def test_multiple_inputs(self):
        for a, b, expect in ([1,1,2], [0,0,0], [2,2,4]):
            self.expect_equal(expect, add(a,b), 'inputs: {} {}'.format(a,b))

2) Lorsque vous voulez vérifier plusieurs sorties d'une fonction. Je veux vérifier chaque sortie, mais je ne veux pas d'un premier échec pour masquer les deux autres.

class MyTest(ExpectingTestCase):
    def test_things_with_no_side_effects(self):
        a, b, c = myfunc()
        self.expect_equal('first value', a)
        self.expect_equal('second value', b)
        self.expect_equal('third value', c)

3) Tester des choses avec de lourds frais d'installation. Les Tests doivent être rapides ou les gens cessent de les utiliser. Certains tests nécessitent une connexion db ou réseau qui prend une seconde ce qui ralentirait vraiment votre test. Si vous testez la connexion db Elle-même, alors vous avez probablement besoin de prendre la vitesse de frappe. Mais si vous testez quelque chose sans rapport, nous voulons faire la configuration lente une fois pour toute une série de contrôles.

avec l'utilisation d'un sous-test, l'exécution ne s'arrêterait pas après le premier échec https://docs.python.org/3/library/unittest.html#subtests

voici un exemple avec deux fail asserts:

class TestMultipleAsserts(unittest.TestCase):

    def test_multipleasserts(self):
        with self.subTest():
            self.assertEqual(1, 0)
        with self.subTest():
            self.assertEqual(2, 0)

Sortie sera:

======================================================================
FAIL: test_multipleasserts (__main__.TestMultipleAsserts) (<subtest>)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./test.py", line 9, in test_multipleasserts
    self.assertEqual(1, 0)
AssertionError: 1 != 0

======================================================================
FAIL: test_multipleasserts (__main__.TestMultipleAsserts) (<subtest>)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./test.py", line 11, in test_multipleasserts
    self.assertEqual(2, 0)
AssertionError: 2 != 0

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures=2)

vous pouvez facilement envelopper subtest comme suit

class MyTestCase(unittest.TestCase):
    def expectEqual(self, first, second, msg=None):
        with self.subTest():
            self.assertEqual(first, second, msg)

class TestMA(MyTestCase):
    def test_ma(self):
        self.expectEqual(3, 0)
        self.expectEqual(4, 0)