Qu'est-ce que les tests unitaires ?

Question

Accepted Answer

Les **tests unitaires** vérifient les **unités** individuelles de code (fonctions, méthodes, classes) en **isolation** — en vérifiant que chaque petit morceau fonctionne correctement de manière autonome. Les tests unitaires sont rapides, ciblés et constituent la fondation d'une bonne stratégie de test.

## Qu'est-ce qu'un test unitaire

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Exemple

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Caractéristiques des bons tests unitaires

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Pourquoi c'est important

Comprendre les tests unitaires est fondamental car **les tests unitaires sont la fondation d'une bonne stratégie de test** — la base de la pyramide des tests — c'est donc une connaissance essentielle et incontournable.

Un test unitaire vérifie le **plus petit morceau de code testable (une fonction ou une méthode) en isolation**, en vérifiant qu'il fonctionne correctement de manière autonome avec des entrées données produisant les sorties attendues.

Comprendre cela — tester une chose à la fois, isolée des dépendances (en simulant les systèmes externes comme les bases de données et les réseaux), rapide et déterministe — est le cœur des tests unitaires.

Les tests unitaires sont précieux car ils sont **rapides** (s'exécutant en millisecondes, vous pouvez en exécuter beaucoup fréquemment pour obtenir rapidement des retours), **ciblés** (pinpointing exactement ce qui s'est cassé quand ils échouent) et forment la **fondation** que la plupart d'une suite de test devrait constituer.

Comprendre les **caractéristiques des bons tests unitaires** — rapides, isolés (en simulant les dépendances, indépendants des autres tests), déterministes (pas de flakiness), testant le comportement et les résultats (pas les détails d'implémentation, donc les tests ne cassent pas lors des refactorisations) et couvrant les cas normaux, les cas limites et les conditions d'erreur — est important pour écrire des tests efficaces qui fournissent une vraie valeur plutôt que des tests fragiles ou de faible valeur.

Les tests unitaires sont la forme de test la plus courante et fondamentale, centrale pour TDD, CI/CD et le développement confiant.

Car les tests unitaires sont la fondation des tests (la base de la pyramide, les tests les plus nombreux et les plus fréquemment exécutés) et comprendre ce qu'ils sont et comment écrire de bons (isolés, rapides, ciblés, testant le comportement) est essentiel pour toute stratégie de test, comprendre les tests unitaires est une connaissance essentielle et fondamentale — la pierre angulaire des tests logiciels que tout développeur devrait comprendre et pratiquer, fondamentale pour vérifier la correctitude du code et permettre le développement confiant et sûr que les bons tests fournissent.