Les Quatre Phases d'un Test :

1. SetUp : préparer l'environnement. Cela peut impliquer la création d'objets dans la base de données, la configuration des états du système comme le démarrage des services ou la mise en place des connexions à la base de données ;
2. Act : exécuter la fonction ou les méthodes à tester ;
3. Assert : vérifier et valider les résultats par rapport aux résultats attendus ;
4. TearDown : nettoyer après chaque test. Cela garantit que les modifications apportées à l'environnement n'affectent pas les tests suivants.

SetUp et tearDown sont des phases optionnelles.

Implémentation de SetUp et TearDown

Les méthodes setUp et tearDown dans Unittest sont des méthodes d'instance appelées avant et après chaque méthode de test, respectivement.

Considérons une classe Book avec des méthodes personnalisées __repr__ et sale.

class Book:
    def __init__(self, title, author, amount):
        self.title = title
        self.author = author
        self.amount = amount

    def __repr__(self):
        return f"<Book {self.title}, written by {self.author}, {self.amount} pieces>"

    def sale(self):
        if self.amount > 0:
            self.amount -= 1
        else:
            return "This book sold out"

L'étape suivante, nous définirons les cas de test à l'intérieur de la classe TestBook.

import unittest

class TestBook(unittest.TestCase):
    def setUp(self):
        print("Setting up the environment for each test.")
        self.book = Book("1984", "George Orwell", 2)

    def tearDown(self):
        print("Cleaning up after each test.")
        del self.book

    def test_sale(self):
        self.book.sale()
        assert self.book.sale() == "This book sold out"

    def test_book_repr(self):
        self.assertEqual(repr(self.book), "<Book 1984, written by George Orwell, 2 pieces>")

Après que le cas test_sale soit passé, le nombre de livres a été réinitialisé à la valeur d'origine pour le test_book_repr car la méthode setUp s'exécute avant chaque test.

SetUp et tearDown au niveau de la méthode garantissent que chaque test s'exécute dans un environnement propre, rendant les tests prévisibles et indépendants.

Implémentation de SetUpClass et TearDownClass

Ce sont des méthodes de classe qui s'exécutent une fois pour toute la classe, au début et à la fin de la suite de tests.

class TestBook(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        """This code will run before all tests"""
        print("Setting up the environment for all tests.")
        cls.book = Book("1984", "George Orwell", 2)

    @classmethod
    def tearDownClass(cls):
        """This code will run after all tests"""
        print("Cleaning up after all tests.")

    def test_sale(self):
        self.book.sale()
        assert self.book.sale() == "This book sold out"

    def test_book_repr(self):
        self.assertEqual(repr(self.book), "<Book 1984, written by George Orwell, 2 pieces>")
        # An AssertionError will occur because the amount was changed in the
        # 'test_sale' and the book was not updated prior to this test.

SetUp et tearDown au niveau de la classe réduisent la surcharge de préparation et de nettoyage des ressources qui sont coûteuses à créer et à détruire.