Qu'est-ce que le test d'intégration ?

Question

Accepted Answer

**Le test d'intégration** vérifie que plusieurs **composants ou unités fonctionnent correctement ensemble** — testant les interactions et les points d'intégration (comme du code avec une base de données, des services s'appelant mutuellement, ou des modules combinés). Il détecte les problèmes que les tests unitaires (qui isolent les unités) ne voient pas.

## Ce que le test d'intégration vérifie

```text
Integration tests verify COMPONENTS WORKING TOGETHER (not in isolation):
  → code + DATABASE (does the data layer actually work with a real DB?)
  → service A calling service B / an external API
  → multiple modules/units combined; the integration POINTS between them
→ catches issues in how parts INTERACT — which unit tests (isolated) can't catch.
```

## Pourquoi les tests d'intégration sont importants (vs tests unitaires)

```text
UNIT tests isolate units (mocking dependencies) → fast, but DON'T verify real integration:
  → a unit can pass its tests but FAIL when combined (wrong assumptions about a dependency,
    a real DB query that's wrong, an API contract mismatch, config issues)
INTEGRATION tests use REAL (or realistic) dependencies → catch these interaction bugs:
  → wiring/configuration errors, data layer issues, contract mismatches between components
→ Integration tests verify the parts actually work TOGETHER.
```

## Exemple et considérations

```js
// integration test: the repository actually works with a (test) database
test('UserRepository saves and retrieves a user', async () => {
  const repo = new UserRepository(testDb);     // REAL test database
  await repo.save({ name: 'Ann' });
  const user = await repo.findByName('Ann');    // real query
  expect(user.name).toBe('Ann');
});
```

```text
→ SLOWER than unit tests (real I/O, setup); use a TEST database/environment
→ Test important integration points (data access, key service interactions, APIs)
→ Fewer than unit tests (the pyramid middle); manage test data/state carefully
```

## Pourquoi c'est important

Comprendre le test d'intégration est important car il **détecte une classe de bugs que les tests unitaires ne peuvent pas** — des problèmes dans la façon dont les composants fonctionnent ensemble — c'est donc une connaissance précieuse pour un test exhaustif.

Bien que les tests unitaires vérifient les unités individuelles isolées (en simulant les dépendances), cet isolement signifie qu'ils **ne peuvent pas vérifier l'intégration réelle** : une unité peut réussir tous ses tests mais échouer lorsqu'elle est réellement combinée avec d'autres (en raison de mauvaises hypothèses sur une dépendance, une requête réelle à une base de données incorrecte, une incompatibilité de contrat d'API, ou des problèmes de configuration). **Les tests d'intégration** comblent cette lacune en testant **les composants fonctionnant ensemble avec des dépendances réelles (ou réalistes)** — vérifiant que le code fonctionne réellement avec une base de données réelle, que les services interagissent correctement, et que les points d'intégration fonctionnent — détectant les bugs de câblage, de couche de données, et de contrat que les tests unitaires isolés ne voient pas.

Comprendre cette relation complémentaire (tests unitaires pour la logique isolée, tests d'intégration pour les interactions réelles) est essentiel pour un test exhaustif, car aucun des deux seul n'est suffisant.

Comprendre les **considérations** — que les tests d'intégration sont plus lents (I/O réel et configuration, donc ils se situent au milieu de la pyramide avec moins de tests que les tests unitaires), utilisent des bases de données/environnements de test, se concentrent sur les points d'intégration importants (accès aux données, interactions de services clés, APIs), et nécessitent une gestion soigneuse des données/états de test — reflète la pratique du test d'intégration.

Les tests d'intégration donnent confiance que les parties assemblées fonctionnent, ce que les tests unitaires seuls ne peuvent pas faire.

Puisque les applications réelles sont composées de composants qui interagissent et que les bugs d'intégration (problèmes de base de données, incompatibilités de contrat, erreurs de configuration) sont courants et échappent aux tests unitaires, et puisque le test d'intégration les détecte en vérifiant que les composants fonctionnent ensemble, comprendre le test d'intégration est une connaissance pratique et précieuse — un complément essentiel aux tests unitaires qui détecte les bugs d'interaction, important pour un test exhaustif qui vérifie non seulement les unités isolées mais aussi que les parties du système fonctionnent réellement correctement ensemble.