Exclure les cas spécifiés avec Python unittest

Résumé

• Ecrivez un moyen de limiter les classes cibles à découvrir avec unittest.
• Dans la première moitié, notez quand vous en aurez besoin.
• Plus tard, nous écrirons le code.
• Il existe un exemple de code de load_tests ().

introduction

Même s'il existe plusieurs moyens de transport pour atteindre la destination dans le monde réel, comme la marche, la voiture et les transports en commun, la destination est l'une des destinations, mais dans quelle mesure chaque moyen peut être affecté par le prix, le temps et l'accident. Il existe des avantages et des inconvénients tels que.

De même, lors de l'écriture de code, il peut y avoir plusieurs façons d'atteindre le même objectif.

Par exemple, lors de la recherche dans un arbre, il existe plusieurs méthodes de recherche telles que la priorité de profondeur et la priorité de largeur, et il existe des avantages et des inconvénients. L'algorithme de tri est similaire. C'est un peu exagéré, mais des cas similaires peuvent se produire dans des cas comme le modèle de conception de stratégie.

Dans le cas de la sélection de la priorité de profondeur dans certains cas et de la priorité de largeur dans certains cas, chaque cas de test sera placé dans le code, et si vous souhaitez effectuer un test de boîte noire qui ne connaît pas le contenu du code, implémentez-le honnêtement Ensuite, il y aura un code de test similaire en double.

Dans un tel cas, j'écrirai une histoire que vous pouvez écrire du code qui limite les cas de test avec load_tests ().

code

À titre d'exemple, envisagez d'implémenter la multiplication des entiers x et y de deux manières, «en ajoutant y x fois» et en «multipliant», et en mettant en œuvre chaque test.

1) Mise en œuvre et test d'addition et de multiplication

Une implémentation naïve aboutirait au code suivant. Commentaire La partie écrite comme "redondante" est redondante.

import unittest

class MultiplyBase(object):
    def multiply(self, n1: int, n2: int) -> int:
        raise NotImplementedError()

class MultiplyPlus(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        ret = 0
        for i in range(0, n1):
            ret += n2
        return ret

class MultiplyAsterisk(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        return n1 * n2

class TestMultiplyBase(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyBase()
        with self.assertRaises(NotImplementedError):
            obj.multiply(2, 3)

class TestMultiplyPlus(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyPlus()
        self.assertEqual(obj.multiply(2, 3), 6)  #Redondant!!

class TestMultiplyAsteriskClass(unittest.TestCase):
    def test_multiply(self):
        obj: MultiplyBase = MultiplyAsterisk()
        self.assertEqual(obj.multiply(2, 3), 6)  #Redondant!!

Je ne me soucie pas vraiment de ce montant, mais c'est difficile quand il est important.

2) Implémentation et test qui élimine les pièces redondantes

Nous allons implémenter un cas de test dans la classe TestCaseHelper et dériver ce cas de test pour créer un cas de test concret.

Avec TestCaseHelper, chaque classe de cas de test n'a besoin que d'implémenter la classe d'objets qu'elle utilise. Cela élimine le code redondant.

Cependant, dans ce cas, la classe TestCaseHelper sera découverte avec le comportement par défaut unittest. Pour cette raison, les cas de test échouent toujours, donc load_tests () empêche TestCaseHelper d'être considéré comme un cas de test.

import unittest

class MultiplyBase(object):
    def multiply(self, n1: int, n2: int) -> int:
        raise NotImplementedError()

class MultiplyPlus(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        ret = 0
        for i in range(0, n1):
            ret += n2
        return ret

class MultiplyAsterisk(MultiplyBase):
    def multiply(self, n1: int, n2: int) -> int:
        return n1 * n2

class TestCaseHelper(unittest.TestCase):
    def _get_multiply_obj(self) -> MultiplyBase:
        raise NotImplementedError()

    def test_multiply(self):
        obj: MultiplyBase = self._get_multiply_obj()
        self.assertEqual(obj.multiply(2, 3), 6)

class TestMultiplyBase(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyBase()

    def test_multiply(self):
        obj: MultiplyBase = self._get_multiply_obj()
        with self.assertRaises(NotImplementedError):
            obj.multiply(2, 3)

class TestMultiplyPlus(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyPlus()

class TestMultiplyAsterisk(TestCaseHelper):
    def _get_multiply_obj(self) -> MultiplyBase:
        return MultiplyAsterisk()

def load_tests(loader, tests, patterns):
    test_cases = (TestMultiplyBase, TestMultiplyPlus, TestMultiplyAsterisk)
    suite = unittest.TestSuite()
    for test_class in test_cases:
        tests = loader.loadTestsFromTestCase(test_class)
        suite.addTests(tests)
    return suite

Vous avez maintenant réussi à exclure certains cas de test avec load_tests ().