Que sont les assertions dans les tests ?

Question

Accepted Answer

**Les assertions** sont des déclarations dans un test qui **vérifient si une condition est vraie** — en s'assurant que le résultat réel correspond au résultat attendu. Ce sont le cœur de la façon dont les tests déterminent le succès ou l'échec : si une assertion échoue, le test échoue.

## Ce que font les assertions

```text
An ASSERTION checks that something is as expected:
  → "assert that the actual value EQUALS the expected value"
  → if TRUE → the assertion passes; if FALSE → the assertion FAILS → the TEST FAILS
→ Assertions are how a test VERIFIES behavior (the "check" part of a test).
```

## Types d'assertion courants

```js
// equality
expect(result).toBe(5);                  // strict equality
expect(obj).toEqual({ name: 'Ann' });    // deep/value equality (objects)

// truthiness / null
expect(value).toBeTruthy();
expect(value).toBeNull();
expect(value).toBeDefined();

// comparisons
expect(count).toBeGreaterThan(0);
expect(price).toBeLessThanOrEqual(100);

// collections / strings
expect(array).toContain('item');
expect(array).toHaveLength(3);
expect(text).toMatch(/pattern/);          // regex

// errors
expect(() => risky()).toThrow();          // expect a function to throw

// negation
expect(value).not.toBe(null);
```

## Bonnes assertions

```text
✓ Assert the SPECIFIC expected outcome (clear what's being checked)
✓ Use the RIGHT matcher (toBe vs toEqual; specific > generic)
✓ Clear FAILURE messages (good assertions/matchers explain what failed)
✓ Don't over-assert (test one behavior) or under-assert (verify the actual result)
```

## Pourquoi c'est important

Comprendre les assertions est fondamental car ce sont **le mécanisme central par lequel les tests vérifient le comportement** — déterminant le succès ou l'échec — donc c'est une connaissance essentielle et incontournable pour écrire n'importe quel test.

Une assertion **vérifie qu'une condition est vraie** (généralement que le résultat réel correspond à un résultat attendu), et c'est la partie « vérification » d'un test : si une assertion réussit la vérification est correcte, et si elle échoue le test échoue.

Sans assertions, un test ne vérifie rien du tout — donc comprendre les assertions est fondamental pour écrire des tests significatifs.

Comprendre les **types d'assertion courants** — l'égalité (strict `toBe` vs profond/valeur `toEqual` pour les objets, une distinction importante), les vérifications de véracité et de null, les comparaisons, les vérifications de collections et de chaînes, les assertions d'erreur (vérifier qu'une fonction lève une erreur), et la négation — est une connaissance pratique nécessaire pour exprimer ce qu'un test doit vérifier.

Comprendre les **bonnes pratiques d'assertion** — assert le résultat attendu spécifique (clairement sur ce qui est vérifié), utiliser le bon matcher (par exemple `toEqual` pour la comparaison d'objets, pas `toBe`), s'assurer que les messages d'erreur sont clairs (pour qu'un test qui échoue explique ce qui s'est passé), et équilibrer les assertions (tester un comportement, mais vérifier le résultat réel) — reflète l'écriture de tests clairs et efficaces.

Puisque les assertions sont comment chaque test vérifie le comportement (la vérification fondamentale qui rend un test significatif) et que les comprendre — les types, les bons matchers, et les bonnes pratiques — est nécessaire pour écrire n'importe quel test qui vérifie réellement quelque chose, comprendre les assertions est une connaissance de test essentielle et fondamentale — le bloc de construction central des tests, nécessaire pour exprimer et vérifier le comportement attendu, et fondamental pour écrire des tests qui vérifient de manière significative la correction, une compétence de base pour quiconque écrit des tests.