Si vous écrivez un test piloté par table go en python, il peut être préférable d'utiliser subTest

introduction

Il semble que les gens de la zone go préfèrent écrire des tests unitaires dans un format appelé test piloté par table (bien que d'autres langages fassent de même). Je ne l'ai pas inventé parce qu'il existait ou existait).

J'ai réfléchi à ce qu'il fallait faire si j'écrivais un test piloté par table en python.

Ecrire normalement avec unittest est long

Par exemple, supposons que vous souhaitiez tester une fonction appelée add comme ceci:

def add(x, y):
    return x + y

Si vous l'écrivez honnêtement dans la plage du module unittest de python, cela ressemble à ce qui suit.

import unittest


class Tests(unittest.TestCase):
    def _callFUT(self, x, y):
        from add import add
        return add(x, y)

    def test_with_positive(self):
        actual = self._callFUT(10, 10)
        self.assertEqual(actual, 20)

    def test_with_zero(self):
        actual = self._callFUT(10, 0)
        self.assertEqual(actual, 10)

    def test_with_negative(self):
        actual = self._callFUT(10, -10)
        self.assertEqual(actual, 0)

    def test_with_biiiiiiiiiig(self):
        actual = self._callFUT(
            10,
            10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
        )
        self.assertEqual(
            actual,
            10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010,
        )

longue. Je suis fatigué.

(CallFUT est religieux. Voir cette zone pour plus de détails)

table driven test

Le test piloté par la table donne une sensation nette. Il semble bon d'utiliser subTest.

import unittest
from collections import namedtuple


class Tests(unittest.TestCase):
    def _callFUT(self, x, y):
        from add import add
        return add(x, y)

    def test_it(self):
        C = namedtuple("C", "msg x y expected")
        candidates = [
            C(msg="with positive", x=10, y=10, expected=20),
            C(msg="with zero", x=10, y=0, expected=10),
            C(msg="with negative", x=10, y=-10, expected=0),
            C(
                msg="with biiiiiiig",
                x=10,
                y=10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
                expected=10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010,
            ),
        ]
        for c in candidates:
            with self.subTest(msg=c.msg):
                actual = self._callFUT(c.x, c.y)
                self.assertEqual(actual, c.expected)

Voici mes préférences personnelles

--Utilisation de namedtuple --Écrire des msg ensemble --_ callFUT (Si la méthode de test se termine par un, il peut ne pas être nécessaire de le séparer)

Comment compter le nombre de sous-tests

En cas de succès, il sera compté comme un.

.
----------------------------------------------------------------------
Ran 1 test in 0.002s

OK

S'il échoue, il sera compté comme N, ce qui est bien.

======================================================================
FAIL: test_it (__main__.Tests) [with positive]
----------------------------------------------------------------------
Traceback (most recent call last):
  File "tests.py", line 26, in test_it
    self.assertEqual(actual, c.expected + 1)
AssertionError: 20 != 21

======================================================================
FAIL: test_it (__main__.Tests) [with zero]
----------------------------------------------------------------------
Traceback (most recent call last):
  File "tests.py", line 26, in test_it
    self.assertEqual(actual, c.expected + 1)
AssertionError: 10 != 11

======================================================================
FAIL: test_it (__main__.Tests) [with negative]
----------------------------------------------------------------------
Traceback (most recent call last):
  File "tests.py", line 26, in test_it
    self.assertEqual(actual, c.expected + 1)
AssertionError: 0 != 1

======================================================================
FAIL: test_it (__main__.Tests) [with biiiiiiig]
----------------------------------------------------------------------
Traceback (most recent call last):
  File "tests.py", line 26, in test_it
    self.assertEqual(actual, c.expected + 1)
AssertionError: 10000[33 chars]000000000000000000000000000000000000000000000000000000000000010 != 10000[33 chars]000000000000000000000000000000000000000000000000000000000000011

----------------------------------------------------------------------
Ran 1 test in 0.003s

FAILED (failures=4)

Lors de l'utilisation de pytest

Quelqu'un peut-il écrire sur un test piloté par table à l'aide de pytest?