Qu'est-ce que les tests paramétrés et les tests pilotés par les données ?

Question

Accepted Answer

**Les tests paramétrés (tests pilotés par les données)** exécutent **la même logique de test avec plusieurs ensembles d'entrées et résultats attendus** — en évitant de dupliquer le test pour chaque cas. Ils facilitent les tests de nombreux scénarios (y compris les cas limites) de manière concise.

## Le problème : tests dupliqués

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Tests paramétrés — un test, plusieurs cas

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

La plupart des frameworks supportent cela (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Avantages

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## Pourquoi c'est important

Comprendre les tests paramétrés (tests pilotés par les données) est précieux car ils rendent **facile le test de nombreux scénarios de manière concise**, ce qui soutient des tests approfondis (en particulier des cas limites), donc c'est une connaissance pratique utile.

Le problème qu'ils résolvent — tester de nombreuses combinaisons d'entrées/sorties nécessiterait autrement de **dupliquer le test pour chaque cas** (fastidieux, répétitif, difficile à maintenir) — est réel, et les tests paramétrés le résolvent en exécutant la **même logique de test sur un tableau de cas**.

Cela rend les tests de nombreux scénarios **concis** (un seul corps de test, plusieurs cas), facilite **l'ajout de cas** (il suffit d'ajouter une ligne de données — ce qui encourage le test de plus d'entrées et de **cas limites**, soutenant la couverture approfondie des cas limites qui détecte les bogues), rapporte **chaque cas séparément** (afin que vous voyiez exactement quelle entrée a échoué, aidant au débogage), et maintient les tests maintenables (le tableau de données documente clairement les cas).

Comprendre que la plupart des frameworks supportent cela (le `test.each` de Jest, le `@parametrize` de pytest, le `@ParameterizedTest` de JUnit) les rend pratiquement applicables dans différentes piles technologiques.

Les tests paramétrés sont idéaux pour les fonctions avec de nombreuses combinaisons d'entrées/sorties — courants pour les fonctions utilitaires, les validateurs, les parseurs et les calculs — où ils permettent de tester l'ensemble des cas (y compris les limites et les cas limites) sans la charge de code de test dupliqué.

Cette façon concise et maintenable d'obtenir une large couverture d'entrées encourage des tests plus approfondis.

Puisque tester de nombreux scénarios (en particulier les cas limites) est important pour des tests approfondis et que les tests paramétrés rendent cela concis et maintenable (en évitant les tests dupliqués, en encourageant une large couverture d'entrées), et puisque les comprendre et comprendre leur support par les frameworks est utile pour des tests efficaces, comprendre les tests paramétrés et les tests pilotés par les données est une connaissance précieuse et pratiquement pertinente — une technique utile pour tester de nombreux cas de manière concise, soutenant la couverture approfondie des cas limites que les tests efficaces exigent, et un outil pratique appliqué partout où les fonctions ont de nombreuses combinaisons d'entrées/sorties à vérifier.