Terraform Infrastructure as Code · Leçon

Tests unitaires avec Terratest

Apprenez à écrire des tests unitaires pour vos modules Terraform avec Terratest, une bibliothèque Go dédiée aux tests du code d’infrastructure.

Tests unitaires avec Terratest est une leçon Terraform Infrastructure as Code gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Terraform Infrastructure as Code, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

Pourquoi tester votre IaC ?

L'infrastructure en tant que code (IaC) vous permet de gérer l'infrastructure comme un logiciel. Comme les logiciels, les configurations IaC peuvent contenir des bogues !

Fiabilité : détecter les erreurs avant le déploiement.
Cohérence : garantir que les ressources sont provisionnées comme prévu.
Confiance : effectuer des modifications avec moins de crainte de perturber l'infrastructure existante.

Tester votre code Terraform est essentiel pour créer des environnements cloud robustes et faciles à maintenir.

Tests unitaires et tests d'intégration

Lors des tests d'une IaC, nous parlons souvent de deux grands types de tests :

Tests unitaires : ils se concentrent sur de petites parties isolées de votre code, comme un seul module Terraform. Ils vérifient que chaque composant fonctionne correctement de manière isolée.
Tests d'intégration : ils vérifient que plusieurs composants ou modules fonctionnent ensemble comme un système, en déployant souvent de véritables ressources dans un environnement cloud.

Dans cette leçon, nous nous concentrerons sur les tests unitaires de vos modules Terraform.

Présentation de Terratest

Terratest est une bibliothèque Go développée par HashiCorp (les créateurs de Terraform), spécialement conçue pour tester le code d'infrastructure.

Elle vous aide à écrire des tests automatisés pour votre code Terraform, Packer, Kubernetes et autre code IaC.
Terratest peut déployer une véritable infrastructure chez votre fournisseur cloud, effectuer des assertions sur celle-ci, puis la supprimer.
Elle est puissante aussi bien pour les tests unitaires que pour les tests d'intégration.

Prérequis de Terratest

Pour commencer avec Terratest, vous aurez besoin de quelques éléments :

Go : Terratest est une bibliothèque Go. Go doit donc être installé (la version 1.13 ou ultérieure est recommandée).
Interface de ligne de commande Terraform : l’interface de ligne de commande Terraform doit être installée et accessible.
Identifiants du fournisseur cloud : si vous déployez de vraies ressources (même pour des tests unitaires qui utilisent une API cloud), vous aurez besoin d’un accès authentifié au fournisseur cloud (par exemple, AWS CLI configuré).

Vous devez également avoir une connaissance élémentaire des concepts de programmation en Go.

Structure des fichiers de test Go

Les tests Terratest sont écrits en Go et suivent les conventions de test standard de Go :

Les fichiers de test se terminent par _test.go (par exemple : main_test.go).
Les fonctions de test commencent par Test (par exemple : TestMyModule(t *testing.T)).
Elles utilisent le paquet intégré testing de Go.

Ces fichiers se trouvent généralement à côté de votre module Terraform ou dans un répertoire test dédié.

Explication de `terraform.Options`

Le cœur d’un test Terraform avec Terratest est la structure terraform.Options. Cet objet indique à Terratest comment exécuter Terraform.

Les principaux champs sont notamment :

TerraformDir : chemin vers votre module Terraform.
Vars : variables d’entrée de votre module Terraform.
EnvVars : variables d’environnement à définir pour le processus Terraform.
BackendConfig : configuration de votre backend Terraform.

Il s’agit de votre modèle pour exécuter les commandes Terraform pendant le test.

Flux de test élémentaire

Un test unitaire Terratest classique pour Terraform suit les étapes suivantes :

Définir les options : créez une structure terraform.Options pointant vers votre module et définissant les variables.
Déployer : utilisez terraform.InitAndApply(t, options) pour initialiser et appliquer votre configuration.
Différer la destruction : ajoutez immédiatement defer terraform.Destroy(t, options) afin de garantir le nettoyage à la fin du test.
Vérifier : utilisez testify/assert de Go ou terraform.Output de Terratest pour vérifier les propriétés ou les sorties des ressources.

Vous obtenez ainsi un environnement de test propre et isolé.

Coder `terraform.Options`

Voici un programme Go simple qui montre comment configurer terraform.Options. Il s’agit d’une étape fondamentale de toute interaction avec Terratest.

package main

import (
	"fmt"
	"path/filepath"
	"github.com/gruntwork-io/terratest/modules/terraform"
)

func main() {
	// Define the path to your Terraform configuration directory.
	// In a real test, this would point to your module under test.
	terraformConfigDir := filepath.Join(".", "my-example-module")

	// Create a terraform.Options object.
	// This struct holds all the configuration for running Terraform via Terratest.
	options := &terraform.Options{
		TerraformDir: terraformConfigDir,
		// You would add input variables here, e.g.:
		// Vars: map[string]interface{}{"instance_type": "t2.micro"},
		// And environment variables, e.g.:
		// EnvVars: map[string]string{"AWS_REGION": "us-east-1"},
	}

	fmt.Println("--- Terratest Options Configuration Demo ---")
	fmt.Printf("Configured Terraform Directory: %s\n", options.TerraformDir)
	fmt.Println("This shows how to initialize Terratest options.")
	fmt.Println("Actual Terratest unit tests are run using 'go test' command.")
}

Vérifier les sorties

Après avoir appliqué votre configuration Terraform, vous voudrez en vérifier les sorties. Terratest fournit des fonctions permettant de récupérer facilement ces valeurs.

terraform.Output(t, options, "output_name") : récupère une sortie sous forme de chaîne de caractères.
terraform.OutputMap(t, options, "output_name") : récupère une sortie sous forme de carte.
terraform.OutputList(t, options, "output_name") : récupère une sortie sous forme de liste.

Vous utilisez ensuite les assertions de test de Go (par exemple, celles de github.com/stretchr/testify/assert) pour vérifier que les sorties correspondent à vos attentes.

Vérifiez votre compréhension

Terratest vous aide à tester votre code Terraform en interagissant avec de vraies ressources cloud. Laquelle des étapes suivantes ne fait NOT pas partie du flux de travail habituel d’un test unitaire Terratest ?

Récapitulatif et prochaines étapes

Vous avez appris les principes fondamentaux des tests unitaires de Terraform avec Terratest !

Terratest est une bibliothèque Go pour tester l’IaC.
Elle vous permet de déployer, de vérifier et de nettoyer une infrastructure cloud réelle.
Ses principaux éléments sont les fichiers _test.go, func TestXxx(t *testing.T) et la structure terraform.Options.
Le flux de travail consiste à définir les options, à appliquer Terraform, à effectuer des vérifications et à garantir le nettoyage avec defer.

Découvrez ensuite comment écrire des vérifications plus complexes et intégrer Terratest à vos pipelines CI/CD pour automatiser les tests.

Questions Fréquemment Posées

La leçon « Tests unitaires avec Terratest » est-elle gratuite ?

Oui — le texte complet de « Tests unitaires avec Terratest » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Terraform Infrastructure as Code, passe à CoddyKit PRO. Le cours Terraform Infrastructure as Code comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tests unitaires avec Terratest » ?

Apprenez à écrire des tests unitaires pour vos modules Terraform avec Terratest, une bibliothèque Go dédiée aux tests du code d’infrastructure. Tu pratiques Terraform Infrastructure as Code avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Terraform Infrastructure as Code ?

Aucune expérience préalable n'est requise. Terraform Infrastructure as Code sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Tests unitaires avec Terratest » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Terraform Infrastructure as Code ?

Oui. Chaque leçon Terraform Infrastructure as Code inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

`validate` et `fmt` de Terraform
Tests unitaires avec Terratest
Tester l’intégration des ressources cloud
Politiques sous forme de code et contrôles de conformité

← Retour à Terraform Infrastructure as Code