Que sont les fixtures de test et les méthodes de setup/teardown ?

Question

Accepted Answer

Les **fixtures de test** sont la configuration fixe (données, objets, état) dont les tests ont besoin pour s'exécuter, et les méthodes **setup/teardown** préparent et nettoient ce contexte avant et après les tests. Elles réduisent la duplication et garantissent que les tests s'exécutent dans un état cohérent et isolé.

## Setup et teardown

```text
SETUP → runs BEFORE tests to prepare the context (create objects, data, connections)
TEARDOWN → runs AFTER tests to CLEAN UP (close connections, delete data, reset state)
→ frameworks provide hooks:
  beforeEach / afterEach → before/after EACH test (fresh state per test — common)
  beforeAll / afterAll → once before/after ALL tests in a group (shared expensive setup)
```

```js
describe('UserService', () => {
  let service, db;
  beforeEach(() => {                 // fresh setup for EACH test (isolation)
    db = createTestDb();
    service = new UserService(db);
  });
  afterEach(() => db.close());        // clean up after each test

test('creates a user', () => { /* uses the fresh service/db */ });
});
```

## Fixtures — état et données de test réutilisables

```text
FIXTURES → predefined data/objects tests use (a known starting state):
  → e.g. a sample user, a set of records, a configured object
  → FACTORIES → generate test data flexibly (build objects with sensible defaults +
    overrides) — better than hardcoded data for varied scenarios
→ reduce duplication; give tests consistent, known data to work with
```

## Bonnes pratiques

```text
✓ Prefer beforeEach (fresh state per test) → ISOLATION (tests don't affect each other)
✓ Clean up in teardown → no leftover state causing flaky/order-dependent tests
✓ Keep setup minimal and clear; use factories for flexible test data
✓ Don't share MUTABLE state across tests (a cause of flakiness/order-dependence)
```

## Pourquoi c'est important

Comprendre les fixtures de test et le setup/teardown est précieux car ils sont **essentiels pour écrire des tests propres, isolés et maintenables**, ce qui en fait une connaissance pratique utile.

Les tests ont besoin d'un contexte de départ cohérent (données, objets, état), et les méthodes **setup/teardown** (les hooks `beforeEach`/`afterEach` et `beforeAll`/`afterAll` que les frameworks fournissent) préparent ce contexte avant les tests et le nettoient après — réduisant la duplication (la configuration partagée écrite une seule fois plutôt que dans chaque test) et garantissant que les tests s'exécutent dans un état connu.

Comprendre ces hooks et quand utiliser chacun (beforeEach pour un état frais par test, beforeAll pour une configuration partagée coûteuse) est nécessaire pour organiser les tests correctement.

Comprendre les **fixtures** (données et objets de test prédéfinis donnant aux tests un état de départ connu) et les **factories** (générant des données de test de manière flexible avec des valeurs par défaut sensibles et des surcharges, mieux que des données codées en dur pour des scénarios variés) est précieux pour fournir aux tests des données cohérentes et gérables.

Plus important encore, comprendre les **bonnes pratiques** se connecte à la qualité des tests : préférer `beforeEach` pour un **état frais par test** assure l'**isolation** (les tests ne s'affectent pas les uns les autres — crucial pour des tests fiables), **nettoyer dans teardown** prévient l'état résiduel qui cause des tests instables dépendants de l'ordre (une source courante d'instabilité), et **ne pas partager d'état mutable entre les tests** évite la dépendance à l'ordre et l'instabilité.

Ces pratiques soutiennent directement l'isolation et le déterminisme des tests que de bons tests exigent.

Puisque les tests ont besoin d'une configuration et d'un nettoyage cohérents, et puisque les fixtures et setup/teardown (utilisés correctement, avec une isolation et un nettoyage appropriés) réduisent la duplication et assurent l'état isolé et déterministe sur lequel les tests fiables dépendent, comprendre les fixtures de test et le setup/teardown est une connaissance précieuse et pertinente en pratique — importante pour écrire des tests propres, isolés et maintenables, soutenant directement l'isolation et le déterminisme qui distinguent les tests fiables des tests instables, une compétence utile appliquée dans l'organisation de pratiquement chaque suite de tests.