Molecule

Fiche express
Type	Framework de test pour rôles et collections Ansible
Techno	Python, YAML (molecule.yml), assertions via pytest/Testinfra
Drivers	Docker (défaut), Podman, Vagrant, delegated (cloud/VM existante)
Éditeur	Ansible/Red Hat (projet historiquement communautaire)
Complémentaire à	ansible-lint (analyse statique)
Voir aussi	Ansible · Ansible cmd · InSpec

Molecule est le framework de test officiel de l'écosystème Ansible : il sert à tester un rôle ou une collection de façon isolée et reproductible, en exécutant réellement le rôle sur une cible jetable (conteneur, VM) puis en vérifiant que le résultat correspond à ce qui est attendu. Là où ansible-lint fait de l'analyse statique (syntaxe, bonnes pratiques, sans rien exécuter), Molecule fait du test dynamique : convergence réelle du rôle et assertions sur l'état obtenu. Les deux sont complémentaires et se retrouvent souvent dans le même pipeline CI.

Scénarios de test

Un scénario Molecule est un répertoire (par défaut molecule/default/) contenant un fichier molecule.yml qui décrit :

• driver — comment provisionner la cible de test (Docker, Vagrant, delegated...) ;
• platforms — la ou les images/cibles à tester (ex. plusieurs distributions Linux) ;
• provisioner — le moteur d'exécution du rôle, quasi toujours ansible ;
• verifier — l'outil d'assertion, historiquement pluggable (Testinfra, Chef InSpec,

 Goss), aujourd'hui recentré sur pytest/Testinfra dans les versions récentes de Molecule
 (détails précis selon version, à vérifier).

# molecule/default/molecule.yml
dependency:
  name: galaxy
driver:
  name: docker
platforms:
  - name: instance-debian
    image: debian:12
  - name: instance-rocky
    image: rockylinux:9
provisioner:
  name: ansible
verifier:
  name: testinfra

Un rôle peut posséder plusieurs scénarios (ex. default, upgrade, multi-node) pour couvrir des cas d'usage différents ; on les crée avec molecule init scenario.

Cycle de vie d'un test

dependency  -> installe les dépendances (rôles/collections Galaxy)
lint        -> analyse statique (yamllint, ansible-lint)
syntax      -> vérifie la syntaxe du playbook de test
create      -> provisionne la cible via le driver
prepare     -> prépare la cible avant le rôle testé (pré-requis)
converge    -> exécute le rôle testé sur la cible (le cœur du test)
idempotence -> ré-exécute le rôle : aucun changement ne doit être signalé
verify      -> lance les assertions (Testinfra/pytest)
destroy     -> détruit la cible de test

molecule test enchaîne toutes ces étapes (utilisé en CI) ; molecule converge seul est pratique en développement itératif, pour ne pas recréer la cible à chaque essai.

Drivers : Docker vs Vagrant vs delegated

Driver	Nature de la cible	Avantage	Limite
Docker	Conteneur	Rapide, léger, par défaut	Pas de vrai noyau/systemd complet selon l'image (mitigé par des images « init »)
Vagrant	Machine virtuelle complète	Fidélité proche de la prod (kernel, systemd, réseau)	Plus lourd et plus lent que Docker
Delegated	Cible fournie par l'utilisateur (VM cloud existante, hôte physique)	Teste sur une cible réaliste déjà provisionnée	Pas de création/destruction automatique

Le choix Docker par défaut privilégie la vitesse d'itération ; Vagrant reste pertinent quand le rôle testé dépend fortement de comportements bas niveau (modules kernel, montage disque, systemd units) mal simulés en conteneur.

Vérification : Testinfra / pytest

Testinfra permet d'écrire les assertions en pytest, avec une API orientée état système :

# molecule/default/tests/test_default.py
import pytest

def test_service_nginx(host):
    svc = host.service("nginx")
    assert svc.is_running
    assert svc.is_enabled

def test_config_file(host):
    f = host.file("/etc/nginx/nginx.conf")
    assert f.exists
    assert f.user == "root"
    assert f.mode == 0o644

def test_port_listening(host):
    assert host.socket("tcp://0.0.0.0:80").is_listening

Ces tests s'exécutent contre la cible réellement provisionnée (via le backend de connexion approprié : docker exec, SSH...), donc les assertions portent sur l'état système effectif, pas sur une simulation.

Intégration continue

Molecule est conçu pour tourner en CI (GitLab CI, GitHub Actions...) : chaque rôle/collection embarque ses scénarios, et le pipeline exécute molecule test à chaque modification, sur plusieurs plateformes (matrice de platforms) en parallèle.

Voir aussi

• Ansible — l'outil dont Molecule teste les rôles/collections
• Ansible cmd · Ansible easystart
• InSpec — langage de test de conformité, parfois utilisé comme verifier alternatif à Testinfra
• Open Policy Agent — policy-as-code générique, portée plus large que le test de rôle