Le quattro fasi di un test:

1. SetUp: preparazione dell'ambiente. Questa fase può includere la creazione di oggetti nel database, la configurazione dello stato del sistema come l'avvio di servizi o la creazione di connessioni al database;
2. Act: esecuzione della funzione o dei metodi da testare;
3. Assert: verifica e controllo dei risultati rispetto agli esiti attesi;
4. TearDown: pulizia dopo ogni test. Questo garantisce che eventuali modifiche all'ambiente non influenzino i test successivi.

SetUp e tearDown sono fasi opzionali.

Implementazione di SetUp e TearDown

I metodi setUp e tearDown in Unittest sono metodi di istanza chiamati rispettivamente prima e dopo ogni metodo di test.

Consideriamo una classe Book con metodi personalizzati __repr__ e 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"

Il passo successivo consiste nel definire i casi di test all'interno della 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>")

Dopo che il caso test_sale è stato superato, il numero di libri viene ripristinato al valore originale per il test_book_repr perché il metodo setUp viene eseguito prima di ogni test.

SetUp e tearDown a livello di metodo garantiscono che ogni test venga eseguito in un ambiente pulito, rendendo i test prevedibili e indipendenti.

Implementazione di SetUpClass e TearDownClass

Questi sono metodi di classe che vengono eseguiti una sola volta per l'intera classe, all'inizio e alla fine della suite di test.

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 e tearDown a livello di classe riducono il carico di lavoro nella preparazione e nella pulizia di risorse costose da creare e distruggere.