Les tests participent, avec la documentation, à assurer la robustesse et la pérennité du logiciel.

Il existe plusieurs types de tests :

• Tests unitaires — Se concentrent sur une unité particulière (composant)

• Tests d’intégration — Vérifient la compatibilité globale des différents composants d’une application

• Tests de régression — Vérifient la stabilité du code précédemment intégré

• Tests de sécurité – Évitent les vulnérabilités du code

• …

Le module unittest intégré à Python permet d’écrire et d’exécuter des tests en offrant :

• une structure organisée pour définir des cas de test,
• des méthodes variées pour vérifier le comportement attendu du code,
• des outils pour exécuter automatiquement les tests et afficher les résultats.

Par exemple, la méthode assertEqual(a, b) permet de vérifier que la valeur de a est bien égale à celle de b. Il existe aussi d’autres assertions comme assertTrue, assertFalse, ou assertRaises pour tester différents aspects du code.

Il est d’usage de rédiger au moins un test par fonction.

Considérons la fonction suivante, qui inverse la capitalisation des caractères d’une chaîne :

def inverse_capitalization (word: str) -> str:
    result = []
    for char in word:
        result.append(char.lower() if char.isupper() else char.upper())
    return ''.join(result)

Par exemple, inverse_capitalization("Hello World!") renverra "hELLO wORLD!".

Grâce à unittest, la fonction précédente peut être testée avec le code suivant :

# Import the function to test
from my_functions import inverse_capitalization
import unittest

# Define a Unittest class
class TestMyFunctions (unittest.TestCase):

    # Good practice is to define one method per function to test
    def test_inverse_capitalization (self):
        self.assertEqual("hello!", inverse_capitalization("HELLO!"))
        # add more tests here, consider corner cases

# Start the tests
if __name__ == "__main__":
    unittest.main()

• Les tests unitaires permettent de s’assurer (semi-automatiquement) que les fonctions se comportent comme prévu

• Avec la documentation, les tests permettent d’écrire des codes maintenables et évolutifs.

• Les tests facilitent également la détection précoce des régressions et des bugs.

• Ils encouragent une meilleure conception du code en incitant à écrire des fonctions plus petites et plus modulaires.