Qu'est-ce que le snapshot testing ?

Question

Accepted Answer

**Le snapshot testing** capture un « snapshot » d'une sortie (généralement la sortie rendue d'un composant UI ou une structure de données) et compare les exécutions futures par rapport à celui-ci — signalant quand la sortie change. C'est utile pour détecter les modifications involontaires, mais il y a des limitations à comprendre.

## Fonctionnement du snapshot testing

```text
1. First run → the test RECORDS the output (e.g. a rendered component) as a SNAPSHOT file
2. Later runs → COMPARE the current output to the saved snapshot:
   → MATCHES → pass; DIFFERS → fail (the output changed)
3. If the change is INTENTIONAL → UPDATE the snapshot (review the diff, then accept)
```

```js
// Jest snapshot test (e.g. a React component)
test('renders correctly', () => {
  const tree = render(<Button label="Click" />).toJSON();
  expect(tree).toMatchSnapshot();    // compares to the stored snapshot
});
```

## Utilisations et avantages

```text
✓ Detect UNINTENDED CHANGES — flags when output changes unexpectedly (UI, serialized data)
✓ FAST to write — no manual assertions for complex output; auto-captures the expected result
✓ Good for UI components (catch unexpected rendering changes), config, large data structures
```

## Limitations (à utiliser avec prudence)

```text
⚠️ Snapshots don't verify CORRECTNESS — they capture whatever output exists (even if WRONG);
   they only detect CHANGE, not that the output is RIGHT
⚠️ BLINDLY UPDATING snapshots (jest -u without reviewing) → defeats the purpose (accepting
   broken output) — a common bad habit
⚠️ Large/brittle snapshots → change often, get rubber-stamped, low value
→ Use for change detection; keep snapshots small/focused; REVIEW snapshot diffs;
  don't rely on them alone (combine with real assertions for behavior).
```

## Pourquoi c'est important

Comprendre le snapshot testing est précieux car c'est une **technique couramment utilisée** (surtout pour l'UI) qui est utile quand elle est bien appliquée, mais problématique quand elle est mal utilisée. Donc, comprendre à la fois sa valeur et ses limitations est une connaissance pratique importante.

Le snapshot testing — capture de sortie (généralement un composant UI rendu ou une structure de données) et comparaison des exécutions futures par rapport au snapshot stocké — est **utile pour détecter les modifications involontaires** : il signale quand la sortie change de façon inattendue (en détectant les modifications accidentelles de rendu UI ou de structure de données), est **rapide à écrire** (capture automatique de la sortie attendue sans assertions manuelles de chaque détail d'une sortie complexe) et convient aux composants UI, à la configuration et aux grandes structures de données.

Comprendre ces avantages explique sa popularité, surtout dans les tests d'UI.

Cependant, comprendre les **limitations est critiquement important** pour l'utiliser bien : les snapshots **ne vérifient pas la correction** — ils capturent quelle que soit la sortie existante (même si elle est incorrecte), ne détectant que le *changement* et non la *justesse* — donc un snapshot peut bloquer une sortie défectueuse.

Le **plus grand piège est mettre à jour aveuglément les snapshots** (exécuter la commande de mise à jour sans examiner les différences), ce qui annule l'objectif en acceptant une sortie potentiellement cassée — une mauvaise habitude courante.

Les grands snapshots fragiles qui changent souvent sont caoutchoutés et fournissent peu de valeur.

Comprendre l'utilisation appropriée — pour la détection de changement, garder les snapshots petits et ciblés, **examiner attentivement les diffs de snapshot** et ne pas s'y fier seuls (combiner avec des assertions de comportement réel) — reflète un jugement mature qui évite les mauvais usages courants.

Comme le snapshot testing est largement utilisé (surtout pour l'UI) et est utile pour la détection de changement mais facilement mal utilisé (bloquer une sortie incorrecte, mettre à jour aveuglément), et comme comprendre à la fois sa valeur et ses limitations importantes permet de l'utiliser bien, comprendre le snapshot testing est une connaissance précieuse et pratiquement pertinente — une technique courante à bien comprendre, où apprécier ses limitations (détection de changement, non correction) et un usage approprié (examiner les diffs, ne pas mettre à jour aveuglément) est tout aussi important que la technique elle-même, reflétant un jugement de test solide.