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 ?

Approche traditionnelle — sans tests

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

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

┌──────────┐     ┌──────────┐     ┌──────────┐
│  RED     │ ──> │  GREEN   │ ──> │ REFACTOR │
│ Test     │     │ Code     │     │ Code     │
│ échoue   │     │ minimal  │     │ propre   │
└──────────┘     └──────────┘     └──────────┘
      ▲                                 │
      └─────────────────────────────────┘
            Nouveau test

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

Sur un rôle nginx maintenu sur 18 mois sans tests, puis refactoré avec TDD :

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

Pratiquer dans le lab

Cette page a un lab d’accompagnement : labs/molecule/introduction/ dans stephrobert/ansible-training.

Le lab pose un premier scénario Molecule complet (molecule.yml + converge.yml + verify.yml) sur le rôle webserver. Tests structure (8 tests) qui valident la conformité du scénario.

cd ~/Projets/ansible-training/labs/molecule/introduction/

cat molecule/default/molecule.yml      # config scenario
cat molecule/default/verify.yml        # tests Ansible-native
pytest -v challenge/tests/             # tests structure

Pour lancer Molecule réellement (nécessite Podman) :

molecule test                          # cycle complet : create → converge → verify → destroy

À 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.

Prochaines étapes

Installation et configuration de Molecule Installer Molecule, drivers, premier scénario

Cycle TDD complet Lab pratique : développer un rôle users en TDD avec Molecule

Scenarios multi-distro Tester votre rôle sur Rocky 9 + AlmaLinux 10 + Debian 12 en parallèle

Tests avec testinfra Quand verify.yml ne suffit pas — tests Python expressifs