Architecture des Tests

Dans les vrais projets, les tests doivent être organisés clairement.

Une bonne architecture de tests permet :

• De mieux comprendre le projet
• De trouver les erreurs rapidement
• De maintenir les tests facilement
• D’éviter le code désorganisé

Les tests sont aussi importants que le reste du programme.

1. Un test = un comportement

Une bonne pratique consiste à tester un seul comportement par fonction.

function testAdd() {

    expect(add(2, 2)).toBe(4);

}

Ici, le test vérifie uniquement la fonction add().

2. Nommage des tests

Les noms des tests doivent être clairs et explicites.

function testCreerMessagePanier() {

}

Un bon nom aide à comprendre immédiatement :

• Ce qui est testé
• Le comportement attendu

3. Regrouper les tests

Les tests sont souvent regroupés dans une fonction principale.

function tests() {

    testAdd();

    testMultiply();

}

tests();

Cette approche centralise l’exécution des validations.

4. Cas nominal

Le cas nominal représente le comportement attendu du programme.

expect(add(1, 1)).toBe(2);

Ce test valide le scénario principal.

5. Cas d’erreur

Les tests doivent aussi vérifier les cas particuliers.

expect(add(0, 0)).toBe(0);

Tester plusieurs scénarios améliore la stabilité du projet.

6. Préparer les données

Plusieurs tests doivent préparer leurs propres données.

const cart = new Map();

cart.set("patate", 1);

Cela permet de créer un contexte précis pour chaque test.

7. Isolation des tests

Les tests doivent être indépendants les uns des autres.

Un test ne devrait pas modifier les données d’un autre test.

function testCart() {

    const cart = new Map();

}

Ici, chaque test possède sa propre collection.

8. Plusieurs assertions

Une fonction de test peut contenir plusieurs assertions.

function testAdd() {

    expect(add(1, 1)).toBe(2);

    expect(add(2, 2)).toBe(4);

}

Cela permet de vérifier plusieurs scénarios similaires.

9. Exemple d’architecture

Exemple inspiré d’un vrai projet.

function testCreerMessagePanier() {

    const cartVide = new Map();

    expect(creerMessagePanier(cartVide))
        .toBe("Votre Panier est vide\n");

}

function testTraiterCommande() {

    const cart = new Map();

    traiterCommande(cart, "add patate");

    expect(cart.get("patate")).toBe(1);

}

function tests() {

    testCreerMessagePanier();

    testTraiterCommande();

}

tests();

10. Lisibilité des tests

Les tests doivent être faciles à lire.

Un développeur devrait rapidement comprendre :

• Les données utilisées
• Le comportement testé
• Le résultat attendu

11. Les tests comme documentation

Les tests servent aussi de documentation du programme.

expect(creerMessagePanier(cart))
    .toBe("1 patate\n");

Ce test montre clairement le comportement attendu.

12. Organiser les fichiers

Dans les gros projets, les tests sont souvent séparés du reste du code.

src/
tests/

Cette structure améliore l’organisation du projet.

13. Éviter les tests géants

Un test trop gros devient difficile à comprendre.

Bonne pratique :

• Créer plusieurs petits tests
• Séparer les comportements
• Utiliser des noms clairs

14. Bonnes pratiques

• Un test = une responsabilité
• Créer des noms explicites
• Tester plusieurs cas
• Isoler les données
• Regrouper les tests dans une fonction principale
• Créer des tests simples et lisibles

Résumé rapide