Pourquoi écrire des tests unitaires ?

Qu'est-ce qu'un test unitaire ? Définition et portée

Un test unitaire est un petit morceau de code qui vérifie qu'une *unité* de code (généralement une fonction, une méthode, ou une classe) se comporte comme prévu.

Un test unitaire est généralement :

• Automatisé : Il peut être exécuté automatiquement, sans intervention humaine.
• Isolé : Il teste une seule unité de code, indépendamment du reste du programme.
• Rapide : Il doit s'exécuter rapidement (généralement en quelques millisecondes).
• Déterministe : Il doit produire le même résultat à chaque exécution, si le code testé ne change pas.
• Vérifiable : Il doit être facile de déterminer si le test a réussi ou échoué (généralement en comparant un résultat attendu avec un résultat réel).

L'objectif d'un test unitaire est de valider que l'unité de code testée fonctionne correctement dans un cas d'utilisation spécifique.

Un ensemble de tests unitaires couvre différents cas d'utilisation et permet de s'assurer que le code fonctionne comme prévu dans un large éventail de situations.

Avantages des tests unitaires : qualité, débogage, refactoring, documentation

Ecrire des tests unitaires présente de nombreux avantages :

• Amélioration de la qualité du code : Les tests unitaires permettent de détecter les bugs tôt dans le cycle de développement, avant qu'ils ne causent des problèmes plus graves.
• Réduction des bugs : En testant chaque unité de code individuellement, vous réduisez le risque d'introduire des bugs et vous vous assurez que le code fonctionne comme prévu.
• Débogage facilité : Lorsqu'un test unitaire échoue, vous savez exactement quelle partie du code est défectueuse. Cela rend le débogage beaucoup plus facile.
• Refactoring facilité : Les tests unitaires vous donnent la confiance nécessaire pour modifier et refactoriser votre code. Si vous modifiez le code et que les tests continuent de passer, vous savez que vous n'avez pas introduit de régressions (de nouveaux bugs).
• Documentation : Les tests unitaires servent de documentation "exécutable" pour votre code. Ils montrent comment le code est censé être utilisé et quels sont les résultats attendus.
• Conception améliorée : L'écriture de tests unitaires vous oblige à réfléchir à la conception de votre code et à la manière dont les différentes parties interagissent. Cela peut conduire à une meilleure conception du code.
• Confiance : Un ensemble de tests unitaires complets vous donne confiance dans la qualité de votre code et vous permet de le modifier et de l'étendre plus sereinement.
• Intégration continue : Les tests peuvent s'intégrer aux outils d'intégration continue.

En résumé, les tests unitaires sont un investissement qui permet d'améliorer la qualité, la maintenabilité et l'évolutivité de votre code.

Exemple de test unitaire simple

Voici un exemple simple de test unitaire en Python, en utilisant le module `unittest` de la bibliothèque standard :

import unittest

# Fonction à tester
def additionner(a, b):
    return a + b

# Classe de test (hérite de unittest.TestCase)
class TestAddition(unittest.TestCase):

    def test_addition_nombres_positifs(self):
        resultat = additionner(2, 3)
        self.assertEqual(resultat, 5)  # Vérifie que le résultat est égal à 5

    def test_addition_avec_zero(self):
        resultat = additionner(5, 0)
        self.assertEqual(resultat, 5)

    def test_addition_nombres_negatifs(self):
        resultat = additionner(-2, -3)
        self.assertEqual(resultat, -5)

# Exécution des tests (si le fichier est exécuté directement)
if __name__ == '__main__':
    unittest.main()

Dans cet exemple :

• `additionner` est la fonction à tester.
• `TestAddition` est une classe de test qui hérite de `unittest.TestCase`.
• `test_addition_nombres_positifs`, `test_addition_avec_zero`, et `test_addition_nombres_negatifs` sont des méthodes de test. Chaque méthode teste un cas d'utilisation spécifique de la fonction `additionner`.
• `self.assertEqual(resultat, valeur_attendue)` est une assertion qui vérifie que le résultat obtenu est égal à la valeur attendue. Si l'assertion est fausse, le test échoue.
• Le bloc `if __name__ == '__main__':` permet d'exécuter les tests lorsque le fichier est exécuté directement (`python mon_fichier.py`).

Les différents types de tests

Il existe différents types de tests, chacun ayant un objectif spécifique :

• Tests unitaires : Testent une unité de code isolée (généralement une fonction ou une méthode).
• Tests d'intégration : Testent l'interaction entre plusieurs unités de code (par exemple, entre différentes classes ou différents modules).
• Tests fonctionnels (ou tests d'acceptation) : Testent le comportement global du système du point de vue de l'utilisateur.
• Tests de performance : Mesurent les performances du système (temps d'exécution, utilisation de la mémoire, etc.).
• Tests de charge : Vérifient le comportement du système sous une charge importante.
• Tests de stress : Poussent le système à ses limites pour identifier les points de rupture.
• Etc.

Les tests unitaires sont généralement les plus nombreux et les plus faciles à écrire. Ils constituent la base d'une stratégie de test solide.

Quand écrire des tests unitaires ?

Il existe différentes approches pour écrire des tests unitaires :

• Avant d'écrire le code (Test-Driven Development, TDD) : Vous écrivez d'abord les tests, puis vous écrivez le code pour que les tests passent. C'est une approche très efficace pour concevoir du code de qualité.
• Après avoir écrit le code : Vous écrivez le code, puis vous écrivez les tests pour vérifier qu'il fonctionne correctement. C'est l'approche la plus courante.
• En même temps que vous écrivez le code : Vous écrivez le code et les tests en parallèle, en itérant sur de petites portions de code.

Quelle que soit l'approche que vous choisissez, il est important d'écrire des tests unitaires pour *tout* le code que vous écrivez (ou du moins, pour la majeure partie du code).

Plus vous écrirez de tests, et plus vous écrirez de tests tôt, moins vous passerez de temps à débugger, et plus votre code sera de qualité.