Wat is integratietesting?

Question

Accepted Answer

**Integratietesting** verifieert dat meerdere **componenten of units correct samenwerken** — het testen van interacties en integratiepunten (zoals code met een database, services die elkaar aanroepen, of gecombineerde modules). Het vangt problemen op die unittests (die units isoleren) missen.

## Wat integratietesting verifieert

```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.
```

## Waarom integratietests belangrijk zijn (versus unittests)

```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.
```

## Voorbeeld en overwegingen

```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
```

## Waarom het belangrijk is

Het begrijpen van integratietesting is belangrijk omdat het **een klasse van bugs vangt die unittests niet kunnen** — problemen in hoe componenten samenwerken — dus het is waardevolle kennis voor uitgebreid testen.

Terwijl unittests individuele units in isolatie verifiëren (met gemockte afhankelijkheden), betekent deze isolatie dat ze **geen echte integratie kunnen verifiëren**: een unit kan alle tests doorstaan maar falen wanneer deze daadwerkelijk met anderen wordt gecombineerd (vanwege verkeerde aannames over een afhankelijkheid, een echte databasequery is onjuist, een API-contract-mismatch, of configuratieproblemen). **Integratietests** vullen deze kloof op door **componenten te testen die samenwerken met echte (of realistische) afhankelijkheden** — verifiërend dat code werkelijk werkt met een echte database, dat services correct interageren, en dat integratiepunten functioneren — vangt de bedrading, gegevenslaag, en contractbugs die geïsoleerde unittests missen.

Het begrijpen van deze complementaire relatie (unittests voor geïsoleerde logica, integratietests voor echte interacties) is essentieel voor uitgebreid testen, omdat geen van beide alleen voldoende is.

Het begrijpen van de **overwegingen** — dat integratietests langzamer zijn (echte I/O en setup, dus ze bevinden zich in het midden van de piramide met minder dan unittests), testdatabases/omgevingen gebruiken, zich richten op belangrijke integratiepunten (gegevenstoegang, sleutelserviceinteracties, API's), en zorgvuldige testgegevensbeheer/state-beheer vereisen — weerspiegelt praktische integratietesting.

Integratietests bieden vertrouwen dat de samengestelde onderdelen werken, wat unittests alleen niet kunnen geven.

Omdat echte applicaties uit interagerende componenten bestaan en integratiebugs (databaseproblemen, contractmismatch, configuratiefouten) gebruikelijk zijn en worden gemist door unittests, en omdat integratietesting ze vangt door te verifiëren dat componenten samenwerken, is het begrijpen van integratietesting waardevolle, praktisch relevante kennis — een essentieel complement op unittesten dat interactiebugs vangt, belangrijk voor uitgebreid testen dat niet alleen geïsoleerde units verifieert, maar dat de onderdelen van het systeem werkelijk correct samenwerken.