GitScrum / Docs
Toutes les Bonnes Pratiques

Développement Piloté par les Tests avec GitScrum

Intégrez les pratiques TDD dans votre workflow agile. Écrivez les tests d'abord, attrapez les bugs tôt et construisez la confiance dans votre code.

4 min de lecture

Le TDD n'est pas juste une question de test - c'est une question de design et de confiance. GitScrum supporte les workflows TDD avec un suivi de tâches qui reflète le cycle rouge-vert-refactor.

Fondamentaux TDD

Le Cycle TDD

CYCLE ROUGE-VERT-REFACTOR:
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│        ┌────────────┐                                      │
│        │   ROUGE    │  ← Écrire test échouant             │
│        │   (Test    │    "Que devrait faire le code?"     │
│        │  Échouant) │                                      │
│        └─────┬──────┘                                      │
│              │                                              │
│              ▼                                              │
│        ┌────────────┐                                      │
│        │   VERT     │  ← Écrire code minimum pour passer  │
│        │   (Test    │    "Le faire marcher, rien de plus" │
│        │  Passant)  │                                      │
│        └─────┬──────┘                                      │
│              │                                              │
│              ▼                                              │
│        ┌────────────┐                                      │
│        │  REFACTOR  │  ← Améliorer sans casser tests      │
│        │   (Code    │    "Le rendre propre"               │
│        │   Propre)  │                                      │
│        └─────┬──────┘                                      │
│              │                                              │
│              └──────────→ Répéter                          │
│                                                             │
│ TEMPS DE CYCLE: Minutes, pas heures                        │
│                                                             │
│ RÈGLES CLÉS:                                                │
│ • Jamais écrire code sans test échouant                   │
│ • Écrire le code minimum pour passer                      │
│ • Refactorer seulement quand tests sont verts             │
│ • Exécuter tests fréquemment                              │
└─────────────────────────────────────────────────────────────┘

Bénéfices TDD

POURQUOI TDD FONCTIONNE:
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│ BÉNÉFICES DESIGN:                                           │
│ • Force à penser interface d'abord                        │
│ • Mène à code modulaire, testable                         │
│ • Attrape problèmes design tôt                            │
│ • Résulte en designs plus simples                         │
│                                                             │
│ BÉNÉFICES QUALITÉ:                                          │
│ • Bugs attrapés immédiatement                             │
│ • Haute couverture tests naturellement                    │
│ • Protection régression                                    │
│ • Confiance pour refactorer                               │
│                                                             │
│ BÉNÉFICES PRODUCTIVITÉ:                                     │
│ • Moins de temps débogage                                 │
│ • Feedback plus rapide                                     │
│ • Documentation via tests                                  │
│ • Onboarding plus facile                                   │
│                                                             │
│ BÉNÉFICES PSYCHOLOGIQUES:                                   │
│ • Petites victoires (tests verts)                         │
│ • Confiance dans le code                                   │
│ • Sûr de changer                                          │
│ • Progrès clair                                           │
│                                                             │
│ SANS TDD:                                                   │
│ Écrire code → Tester après → Trouver bugs → Debug → Fix  │
│                                                             │
│ AVEC TDD:                                                   │
│ Écrire test → Écrire code → Test passe → Refactor → Fait │
└─────────────────────────────────────────────────────────────┘

TDD en Pratique

Exemple de Workflow

EXEMPLE TDD - AJOUTER AU PANIER:
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│ STORY: "En tant qu'utilisateur, je peux ajouter items    │
│         à mon panier"                                      │
│                                                             │
│ CYCLE TDD 1:                                                │
│                                                             │
│ ROUGE: Écrire test                                         │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ test('ajoute item à panier vide', () => {              ││
│ │   const cart = new Cart();                             ││
│ │   cart.add(item);                                      ││
│ │   expect(cart.items.length).toBe(1);                   ││
│ │ });                                                     ││
│ │ // Résultat: ❌ ÉCHOUE - Cart n'existe pas             ││
│ └─────────────────────────────────────────────────────────┘│
│                                                             │
│ VERT: Écrire code minimum                                  │
│ ┌─────────────────────────────────────────────────────────┐│
│ │ class Cart {                                           ││
│ │   items = [];                                          ││
│ │   add(item) { this.items.push(item); }                ││
│ │ }                                                       ││
│ │ // Résultat: ✅ PASSE                                  ││
│ └─────────────────────────────────────────────────────────┘│
│                                                             │
│ REFACTOR: (Rien à refactorer encore)                       │
│                                                             │
│ CYCLE TDD 2: Ajouter comportement suivant...              │
└─────────────────────────────────────────────────────────────┘

Solutions Connexes