0Pricing
JavaScript Academy · Leçon

État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation

Prenez l’habitude d’écrire de petits tests : comprenez les assertions, Arrange–Act–Assert et la boucle rouge→vert→refactorisation

État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. 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 JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 3 leçons au total.

Pourquoi adopter une mentalité de test ?

Objectif : raisonner avec de petits tests fiables.

  • Petite assertion pour vérifier les résultats
  • AAA : préparer → agir → vérifier
  • Boucle rouge → vert → refactoriser
  • Nommez les tests selon le comportement
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 1

Une petite assertion

Un petit assertEqual affiche la réussite ou l’échec. Cela reproduit le fonctionnement des véritables cadres de test.

// Minimal assertEqual for quick checks
function assertEqual(actual, expected, name) {
  if (actual === expected) {
    console.log("✅", name);
  } else {
    console.log("❌", name, "expected:", expected, "got:", actual);
  }
}

// Demo check
assertEqual(2 + 3, 5, "adds numbers");
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 2

Préparer–Agir–Vérifier

AAA rend les tests lisibles : préparez les données, appelez la fonction, puis vérifiez le résultat.

// AAA: Arrange → Act → Assert
// Arrange: prepare inputs
function sum(a, b) { return a + b; }
const a = 2;
const b = 4;

// Act: call the function
const result = sum(a, b);

// Assert: compare
assertEqual(result, 6, "sum returns a + b");
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 3

Rouge→Vert→Refactoriser

Écrivez un test qui échoue (rouge), faites-le réussir (vert), puis nettoyez le code (refactoriser).

// Red → Green → Refactor with a tiny example
// 1) Red: write a failing test (expect wrong implementation)
function greet(name) { return "Hi " + name; } // simple implementation

// Intentionally failing expectation first (red)
assertEqual(greet("Ayla"), "Hello Ayla", "greet says Hello"); // likely fails

// 2) Green: fix the code to satisfy the test
function greetFixed(name) { return "Hello " + name; }
assertEqual(greetFixed("Ayla"), "Hello Ayla", "greet says Hello (fixed)");

// 3) Refactor: improve code without changing behavior
function greetRefined(name) {
  const cleaned = String(name).trim();
  return "Hello " + cleaned;
}
assertEqual(greetRefined(" Ayla "), "Hello Ayla", "greet trims input");
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 4

Noms axés sur le comportement

Nommez les vérifications selon ce que la fonction doit faire : limites et cas courants.

// Clear names describe behavior, not internals
function isAdult(age) { return age >= 18; }

assertEqual(isAdult(18), true, "isAdult returns true at boundary 18");
assertEqual(isAdult(17), false, "isAdult returns false below boundary");
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 5

Tests courts et ciblés

Conseils :

  • Gardez les tests courts et ciblés (une seule idée par test).
  • Testez le scénario nominal et une limite.
  • Préférez les fonctions pures pour faciliter les tests.
  • Automatisez plus tard avec Jest/Vitest ; commencez par adopter la bonne mentalité.
État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 6

Quiz sur le modèle AAA

Vérification rapide : modèle AAA.

État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 7

Récapitulatif

Récapitulatif : utilisez une petite assertion, suivez AAA et répétez Rouge → Vert → Refactoriser. Commencez simplement : pour les débutants, la clarté prime sur la complexité.

État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation — illustration 8

Questions Fréquemment Posées

La leçon « État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation » est-elle gratuite ?

Oui — le texte complet de « État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation » 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 JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation » ?

Prenez l’habitude d’écrire de petits tests : comprenez les assertions, Arrange–Act–Assert et la boucle rouge→vert→refactorisation Tu pratiques JavaScript Academy 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 JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript Academy 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 1 sur 3.

Combien de temps prend la leçon « État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation » ?

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 JavaScript Academy ?

Oui. Chaque leçon JavaScript Academy 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

  1. État d’esprit des tests — petites assertions, AAA, rouge→vert→refactorisation
  2. Analyse du code avec ESLint ; formatage avec Prettier
  3. Notions de base de l’intégration continue — lint et tests à chaque envoi
← Retour à JavaScript Academy