Wenn Sie einen go table-gesteuerten Test in Python schreiben, ist es möglicherweise besser, subTest zu verwenden

Einführung

Es scheint, dass Leute im Go-Bereich es vorziehen, Komponententests in einem Format namens tabellengesteuerter Test zu schreiben (obwohl andere Sprachen dasselbe tun). Ich habe es nicht erfunden, weil es existierte oder existierte.

Ich überlegte, was ich tun sollte, wenn ich einen tabellengesteuerten Test in Python schrieb.

Normalerweise mit unittest zu schreiben ist lang

Angenommen, Sie testen die folgende Funktion namens add.

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

Wenn Sie es ehrlich im Bereich des unittest-Moduls von Python schreiben, sieht es wie folgt aus.

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

lange. Ich bin müde.

(CallFUT ist religiös. Weitere Informationen finden Sie in diesem Bereich.)

table driven test

Der tischgetriebene Test vermittelt ein klares Gefühl. Es scheint gut zu sein, subTest zu verwenden.

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)

Unten sind meine persönlichen Vorlieben

• Mit namedtuple
• Schreibe eine Nachricht zusammen --_ callFUT (Wenn die Testmethode mit eins endet, muss sie möglicherweise nicht getrennt werden.)

So zählen Sie die Anzahl der Untertests

Bei Erfolg wird es als eins gezählt.

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

OK

Wenn es fehlschlägt, wird es als N gezählt, was gut ist.

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

Bei Verwendung von Pytest

Kann jemand über einen tischgesteuerten Test mit pytest schreiben?