Exécuter les tests

Exécution de tests avec unittest.main()

La manière la plus simple d'exécuter des tests écrits avec le module `unittest` est d'ajouter le bloc suivant à la fin de votre fichier de test :

if __name__ == '__main__':
    unittest.main()

Lorsque vous exécutez le fichier Python (par exemple, `python mon_fichier_de_test.py`), la fonction `unittest.main()` :

1. Découvre automatiquement les classes de test (les classes qui héritent de `unittest.TestCase`) et les méthodes de test (les méthodes dont le nom commence par `test`) dans le fichier courant.
2. Crée une suite de tests contenant tous les tests découverts.
3. Exécute les tests.
4. Affiche un rapport des résultats (tests réussis, tests échoués, erreurs) sur la console.

Exemple (fichier `test_mon_module.py`) :

import unittest

def additionner(a, b):
    return a + b

class TestAddition(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(additionner(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

Exécution :

python test_mon_module.py

Sortie (exemple) :

.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

La sortie indique que 1 test a été exécuté et qu'il a réussi (`OK`). Si un test échoue, vous verrez des informations détaillées sur l'échec (quelle assertion a échoué, quelle était la valeur attendue, quelle était la valeur réelle, etc.).

Exécution de tests depuis la ligne de commande

Vous pouvez également exécuter vos tests depuis la ligne de commande, en utilisant le module `unittest` comme un outil. Cela offre plus de flexibilité et d'options.

Syntaxe de base :

python -m unittest nom_du_fichier_de_test.py

• `python -m unittest` : Exécute le module `unittest` en tant que script.
• `nom_du_fichier_de_test.py` : Le nom du fichier Python contenant les tests (sans le `.py`, vous pouvez aussi spécifier le nom d'un module importable).

Exemple (en reprenant l'exemple précédent) :

python -m unittest test_mon_module

Vous pouvez spécifier une classe de test particulière :

python -m unittest test_mon_module.TestAddition

Ou même une méthode de test particulière :

python -m unittest test_mon_module.TestAddition.test_addition

Découverte automatique des tests : python -m unittest discover

Si vous avez plusieurs fichiers de test, ou si vos tests sont organisés en répertoires, vous pouvez utiliser la *découverte automatique* des tests.

La commande suivante recherche récursivement tous les fichiers nommés `test*.py` dans le répertoire courant (et ses sous-répertoires) et exécute tous les tests qu'ils contiennent :

python -m unittest discover

Vous pouvez spécifier un répertoire de départ différent :

python -m unittest discover -s mon_repertoire_de_tests

Vous pouvez utiliser l'option `-p` (pattern) pour spécifier un motif différent pour les noms de fichiers de test :

python -m unittest discover -p '*_test.py'

La découverte automatique est très pratique pour exécuter tous les tests d'un projet en une seule commande.

Options de ligne de commande utiles

Voici quelques options de ligne de commande utiles lorsque vous exécutez des tests avec `unittest` :

• `-v` (verbose) : Affiche des informations plus détaillées sur les tests exécutés (le nom de chaque méthode de test, etc.). Exemple : `python -m unittest -v mon_fichier_de_test.py`
• `-q` (quiet) : Affiche moins d'informations (seulement les erreurs et les échecs).
• `-f` (failfast) : Arrête l'exécution des tests dès le premier échec ou erreur.
• `-b` (buffer) : Met en mémoire tampon la sortie standard et la sortie d'erreur pendant l'exécution des tests. La sortie n'est affichée que si le test échoue ou si une erreur se produit.
• `-k` : Exécute seulement les tests dont le nom correspond à un motif.
• `--locals` : Affiche les variables locales dans les traces d'appels (tracebacks) en cas d'erreur.

Exemple (utilisation de `-v` et `-k`):

python -m unittest -v -k test_addition mon_fichier_de_test.py

Cette commande exécute en mode verbeux (`-v`) uniquement les tests dont le nom contient "test_addition" dans le fichier `mon_fichier_de_test.py`.

Autres frameworks de test (pytest, nose2)

Bien que `unittest` soit un framework de test puissant et flexible, il existe d'autres frameworks de test populaires en Python, qui offrent des fonctionnalités supplémentaires et une syntaxe plus concise.

Les plus courants sont :

• `pytest` : Un framework de test très populaire, qui simplifie l'écriture des tests, offre de nombreuses fonctionnalités avancées (fixtures, parametrization, plugins), et fournit des rapports de test clairs et informatifs.
• `nose2` : Un successeur de `nose`, qui est un autre framework de test populaire. Il offre des fonctionnalités similaires à `pytest`.

Ces frameworks utilisent généralement la découverte automatique des tests et des conventions de nommage similaires à `unittest`, mais ils offrent une syntaxe plus concise pour les assertions et des fonctionnalités supplémentaires.

Exemple (avec `pytest`, qui n'a pas besoin de classe. Il suffit de créer un fichier `test_*.py` ou `*_test.py`):

# test_exemple.py
def additionner(a, b):
    return a + b

def test_addition():
    assert additionner(2, 3) == 5
    assert additionner(0, 0) == 0
    assert additionner(-1, 1) == 0

Exécution :

pytest

Il est recommandé de se familiariser avec `pytest`, car il est devenu le framework de test de facto pour de nombreux projets Python.