De fire faser i en test:

1. SetUp: forbered miljøet. Dette kan indebære oprettelse af objekter i databasen, konfiguration af systemtilstande som opstart af tjenester eller opsætning af databaseforbindelser;
2. Act: udfør funktionen eller metoderne, der skal testes;
3. Assert: kontroller og verificer resultaterne i forhold til de forventede resultater;
4. TearDown: oprydning efter hver test. Dette sikrer, at ændringer i miljøet ikke påvirker efterfølgende tests.

SetUp og tearDown er valgfrie faser.

Implementering af SetUp og TearDown

Metoderne setUp og tearDown i Unittest er instansmetoder, der kaldes før og efter hver testmetode.

Lad os overveje en Book-klasse med en tilpasset __repr__ og sale-metoder.

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"

Næste trin er at definere testcases i TestBook-klassen.

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

Efter test_sale-casen er gennemført, nulstilles antallet af bøger til den oprindelige værdi for test_book_repr, fordi setUp-metoden køres før hver test.

SetUp og tearDown på metodeniveau sikrer, at hver test udføres i et rent miljø, hvilket gør tests forudsigelige og uafhængige.

Implementering af SetUpClass og TearDownClass

Disse er klassemetoder, der køres én gang for hele klassen, i starten og slutningen af test-suiten.

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 og tearDown på klasseniveau reducerer omkostningerne ved at forberede og rydde op i ressourcer, der er dyre at oprette og destruere.