TDD avec Molecule : développement piloté par les tests pour rôles Ansible

Le TDD (Test-Driven Development) inverse le flux d'écriture d'un rôle Ansible : vous écrivez d'abord le test qui décrit le comportement attendu, vous le voyez échouer (rouge), puis vous codez le minimum pour le faire passer (vert), puis vous refactorez sans peur (les tests garantissent la non-régression).

Cette pratique, importée du monde Python/Java, est encore rare en Ansible, la plupart des dev écrivent le rôle puis ajoutent des tests « si ils ont le temps ». Ce guide vous fait adopter le cycle TDD avec Molecule dès votre prochain rôle. ROI : moins de régressions, refactor sans peur, couverture intégrée.

Ce que vous allez apprendre

La philosophie TDD : pourquoi tester d'abord ?
Le cycle red-green-refactor appliqué à Ansible.
L'outil Molecule : framework de test orchestré pour rôles.
Les bénéfices mesurables : régressions évitées, refactor facilité.
La stack 2026 : Molecule v6+ ansible-native + verify.yml Ansible.

Prérequis

Avoir un rôle écrit (pour comparer le « avant TDD »).
Podman ou Docker installé (Molecule utilise des conteneurs comme cible de test).
Ansible 2.16+ et Python 3.10+.

Pourquoi le TDD pour Ansible ?

Un rôle Ansible n'a pas de compilateur pour signaler ses erreurs : la seule boucle de retour disponible est l'exécution réelle sur une machine. Sans test automatisé, cette exécution se fait à la main, sur une VM déjà sale, et son verdict repose sur ce que l'auteur pense à vérifier ce jour-là. Les deux enchaînements ci-dessous opposent ce fonctionnement au cycle piloté par les tests : ils décrivent le même travail, dans un ordre inversé.

Approche traditionnelle, sans tests

Voici la séquence que suit la majorité des rôles, où le test n'existe que sous forme d'inspection visuelle après coup.

1. J'écris tasks/main.yml
2. Je lance ansible-playbook sur ma VM
3. Je vois si ça marche
4. Si KO, je débugge à l'œil
5. Je passe au feature suivant

Problèmes :

Régressions : modifier un handler casse silencieusement le déploiement 6 mois plus tard.
Pas d'idempotence garantie : command: partout, changed=true à chaque run.
Couverture multi-distro inexistante : ça marche sur Ubuntu, plante sur RHEL.
Refactor risqué : on ne sait pas si la version 2 fait la même chose que la version 1.

Approche TDD, avec Molecule

La même construction, en commençant par verify.yml : chaque assertion est écrite avant la tâche qui la satisfera, et le compteur de tests verts sert d'avancement.

1. J'écris verify.yml AVANT tasks/main.yml
   "Le service nginx doit être running"
   "Le port 80 doit être ouvert"
   "Le fichier /etc/nginx/nginx.conf doit exister"

2. Je lance `molecule verify` → ROUGE (rôle vide)

3. J'écris tasks/main.yml MINIMAL pour passer le 1er test
4. Je lance `molecule verify` → 1/3 VERT, 2/3 ROUGE

5. J'ajoute du code pour passer le 2e test
6. Je relance → 2/3 VERT

7. Je continue jusqu'à TOUT VERT

8. Je REFACTOR le code (extraire en tasks séparées, optimiser)
   sans peur car les tests garantissent la non-régression.

Bénéfices mesurables :

Spécification claire : le test décrit le comportement avant l'implémentation.
Couverture 100 % : chaque feature a son test dès le départ.
Refactor sans peur : modifier le code, relancer les tests, savoir si ça casse.
Multi-distro automatique : Molecule lance les tests sur Debian + RHEL + AlmaLinux en parallèle.

Le cycle red-green-refactor

Le TDD tient dans une boucle de trois phases que l'on répète pour chaque comportement ajouté au rôle, pas une fois pour tout le rôle. Le point d'entrée est toujours un test rouge : voir le test échouer prouve qu'il teste bien quelque chose, un test qui passe dès sa première exécution ne vérifie rien. Le schéma ci-dessous montre le retour de boucle, qui repart vers un nouveau test après chaque refactorisation.

Cycle TDD en trois phases : RED, le test échoue avant tout code, puis GREEN, le code minimal qui le fait passer, puis REFACTOR, le nettoyage à tests verts, avec un retour de boucle vers RED pour le comportement suivant

3 phases :

Red, Écrire un test qui échoue (le rôle ne fait pas encore ce qu'il faut).
Green, Écrire le minimum de code pour faire passer le test.
Refactor, Améliorer la qualité du code sans changer son comportement (extraction, renommage, optimisation). Les tests garantissent qu'on ne casse rien.

Qu'est-ce que Molecule ?

Molecule est le framework officiel de test pour rôles Ansible, maintenu par la communauté ansible-community sous gouvernance Red Hat.

Il orchestre un cycle complet de test :

1. create     : provisionne un container Podman/Docker
2. prepare    : exécute des prérequis (paquets de base, etc.)
3. converge   : joue le rôle à tester
4. idempotence : re-joue le rôle, vérifie changed=0
5. verify     : exécute les assertions de verify.yml
6. destroy    : supprime le container

Avantages :

Isolation : chaque test tourne dans un container neuf, pas d'effet de bord.
Multi-distro : matrice (platforms:) lance le test sur N distros en parallèle.
Reproductible : le scénario est versionné dans le repo (molecule/default/).
CI/CD-friendly : molecule test suffit dans une pipeline GitHub Actions / GitLab CI.

Stack 2026, Molecule v6+ ansible-native

Évolution importante : depuis Molecule 6, le driver delegated (alias default) remplace les drivers Python historiques (Docker, Podman, Vagrant). La création/destruction des containers passe par les collections Ansible (containers.podman, community.docker).

Élément	2020-2023	2026 recommandé
Driver	`driver: docker` (plugin Python)	`driver: default` + `containers.podman`
Verifier	testinfra (Python)	`verifier: ansible` (verify.yml)
Image	`centos:7` minimal	`rockylinux:9` ou `almalinux/10-init`
Tests d'idempotence	Manuel	Native dans `test_sequence`

Conséquence pédagogique : tout tutoriel Molecule avant 2024 est probablement obsolète, copier-coller cassera. Cette section enseigne uniquement Molecule v6+.

Le ROI réel

Le coût du TDD est immédiat et visible : écrire verify.yml avant tasks/main.yml allonge la première journée de développement. Le gain, lui, arrive plus tard et se mesure sur la durée de vie du rôle, ce qui explique qu'il soit si souvent négligé. Le tableau compare un rôle nginx maintenu 18 mois sans tests, puis repris avec le cycle TDD, ligne à ligne sur les mêmes critères.

Métrique	Sans tests	Avec TDD
Régressions découvertes en prod	3 par an	0
Temps moyen de debug d'une régression	4h	N/A
Confiance pour refactorer	Très basse	Haute
Onboarding nouveau dev	« bonne chance »	`molecule test` puis lire `verify.yml`
Documentation à jour	README souvent obsolète	Tests = doc exécutable

Mettre en pratique

Le cycle décrit plus haut ne devient concret qu'en ouvrant les fichiers qui le pilotent. Ce lab vous fait disséquer un scénario molecule/default/ complet : le molecule.yml avec son driver et ses plateformes, le converge.yml qui joue le rôle, et le verify.yml qui interroge le résultat. Vous déroulez ensuite le cycle complet, de la création du conteneur à sa destruction, et la correction contrôle la conformité du scénario obtenu.

Molecule : anatomie d'un scénario de test

$ dsoxlab run molecule-introduction

Environnement : Shell·Durée : ~45 min

Validé : la sortie produite est comparée au résultat attendu.

Première fois ? Qu'est-ce que dsoxlab et comment l'installer

dsoxlab est la ligne de commande qui prépare un environnement jetable (un shell isolé ou une VM), déroule le scénario du lab, puis vérifie l'état réel du système et calcule un score. Rien n'est installé ni cassé sur votre poste de travail.

Installer la CLI dsoxlab, une seule fois :

uv tool install dsoxlab   # ou : pipx install dsoxlab
git clone https://github.com/stephrobert/ansible-training.git
cd ansible-training

Lancer ce lab, puis valider votre travail :

dsoxlab run molecule-introduction
dsoxlab check molecule-introduction

Voir tous les labs : dsoxlab list-labs. Suivre sa progression : dsoxlab progress.

À retenir

TDD = écrire le test avant le code. Cycle red-green-refactor.
Molecule = framework officiel de test pour rôles Ansible.
Stack 2026 : Molecule v6+ + driver delegated + verifier ansible (verify.yml).
Bénéfices : spécification claire, refactor sans peur, multi-distro automatique.
Tests = doc exécutable : un test qui passe documente le comportement réel.

Pour aller plus loin

Cycle TDD complet : le rouge-vert-refactor déroulé sur un vrai rôle, trois cycles commentés.
Scenarios multi-distro : étendre la matrice à plusieurs distributions, le bénéfice le plus visible de Molecule.
CI GitHub Actions : faire tourner ces tests à chaque push plutôt qu'à la main.