Prérequis

Pour lire ce micro-tutoriel, vous devez être familier avec:

• les tests unitaires en Python
• les docstrings

A quoi servent les tests ?

Dans le cycle de création d'un logiciel, il arrive inévitablement qu'un programmeur teste le code qu'il a écrit, pour vérifier qu'il se comporte comme prévu. On parle de tests unitaires et tests fonctionnels. Ce tutoriel ne concerne que les tests unitaires.

-> Plus d'infos sur les preceptes de XP

Les tests unitaires

Les tests unitaires testent de manière isolée les fonctionnalités d'un module ou package, sans se soucier du reste du logiciel, pour vérifier qu'ils répondent bien aux cas d'utilisations.

-> Plus d'infos sur cette page du site de design-up

Les outils de test en Python

Python fourni dans la librairie standard un framework de tests pour faciliter l'écriture et l'utilisation des tests unitaires. Comme pour la plupart des langages actuels, ce framework est inspiré des travaux de Kent Beck, qui a conçu un premier outil sous Smalltalk, porté par la suite sous Java, sous le nom de JUnit.

-> Plus d'infos sur Kent Beck et le GoF: Kent Beck sur Wikipedia

Le framework Python est composé de deux modules: unittest et doctest

Le module unittest fourni le même type d'implémentation que les outils existants en Java, Ruby, et autres langages modernes. Le module doctest fourni quant à lui un principe original pour créér des tests.

Le module doctest

Le module doctest permet de concevoir des tests unitaires dans les docstrings du code. Dans le fichier ci-dessous, le docstring de la fonction somme() intègre un test qui ressemble à une session de prompt Python:

import doctest

def somme(a, b):
    """ renvoie a + b

    >>> somme(2, 2)
    4
    >>> somme(2, 4)
    6
    """
    return a + b

if __name__ == "__main__":
    doctest.testmod()

-> Plus d'infos sur ce module ici: module doctest

Dans notre example, la fonction docttest.testmod() scrute le fichier et exécute ces séquences pour vérifier que les résultats sont corrects:

tziade@Tarek:~/Desktop$ python somme.py -v
Trying:
    somme(2, 2)
Expecting:
    4
ok
Trying:
    somme(2, 4)
Expecting:
    6
ok
1 items had no tests:
    __main__
1 items passed all tests:
2 tests in __main__.somme
2 tests in 2 items.
2 passed and 0 failed.
Test passed.

L'option -v permet de détailler les tests effectués.

Documentation agile

Une extension de ce principe est de séparer ces tests dans un fichier texte.

On retrouve alors un fichier source somme.py classique:

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

Et un fichier texte somme.txt, qui contient les tests associés, mais également la documentation relative au module

---------------
Module somme.py
---------------

Le module somme.py permet de calculer des sommes

>>> from somme import somme
>>> somme(2, 2)
4
>>> somme(2, 4)
6

-> Plus d'exemples sur la documentation agile: doctest séparés

L'interêt principal de cette approche est de permettre au développeur de documenter ses modules en les agrémentant d'exemples qui sont réelements exécutés. On parle alors de documentation agile.

Exécution du document:

>>> import doctest
>>> doctest.testfile('somme.txt', verbose=True)
Trying:
    from somme import somme
Expecting nothing
ok
Trying:
    somme(2, 2)
Expecting:
    4
ok
Trying:
    somme(2, 4)
Expecting:
    6
ok
1 items passed all tests:
3 tests in somme.txt
3 tests in 1 items.
3 passed and 0 failed.
Test passed.
*** DocTestRunner.merge: 'somme.txt' in both testers; summing outcomes.
(0, 3)

Enfin, si votre documentation logiciel est en OOo, un projet intéressant développé par Olivier Grisel, permet de lancer des tests contenus dans des fichiers OpenOffice: oodoctest

Conclusion

J'espere que ce petit aperçu aura piqué la curiosité des développeurs qui ne connaissent pas cette technique originale, qui a été adopté par des projets majeurs comme Zope 3.

Si vous voulez creuser le sujet, allez regarder ce qui se fait dans le svn de Zope 3.