Wat is de testpyramide?

Question

Accepted Answer

De **testpyramide** is een model voor het structureren van een testsuite — met **veel snelle unit tests** aan de basis, **minder integratietests** in het midden, en **enkele end-to-end tests** aan de top. Het begeleidt een evenwichtige, efficiënte teststrategie.

## De pyramide

```text
        /\
       /E2E\        ← FEW end-to-end tests (slow, broad, brittle, expensive)
      /------\
     / INTEG. \     ← SOME integration tests (medium speed/scope)
    /----------\
   /   UNIT     \   ← MANY unit tests (fast, focused, cheap) — the BASE
  /--------------\
```

```text
BASE (most): UNIT tests — fast, isolated, cheap → run lots of them
MIDDLE: INTEGRATION tests — components together → fewer (slower, more setup)
TOP (fewest): E2E tests — whole app, user flows → few (slow, brittle, expensive)
```

## Waarom deze vorm

```text
✓ UNIT tests are FAST, CHEAP, RELIABLE, and pinpoint failures → have MANY (the foundation)
✓ E2E tests are SLOW, EXPENSIVE, and BRITTLE (flaky, hard to debug) → have FEW
  (only critical flows)
✓ Balance: fast feedback (lots of unit tests) + confidence the whole thing works
  (some integration + a few E2E)
→ Most tests should be fast unit tests; reserve slow E2E for the most important flows.
```

## Anti-patronen

```text
✗ ICE CREAM CONE (inverted) → mostly slow E2E/manual tests, few unit tests → slow,
  brittle, expensive test suite (a common bad pattern)
✗ Too many E2E tests → slow CI, flaky tests, hard to maintain
→ The pyramid shape avoids these.
```

## Waarom het belangrijk is

Het begrijpen van de testpyramide is waardevol omdat het **essentiële richtlijnen biedt voor het effectief structureren van een testsuite**, dus het is belangrijk om een gezonde teststrategie te hebben.

Het pyramidemodel — **veel snelle unit tests aan de basis, minder integratietests in het midden, en enkele end-to-end tests aan de top** — vat het kernprincipe samen van het balanceren van testdekking met snelheid en onderhoudbaarheid.

Het begrijpen van **waarom deze vorm** is het kernidee: unit tests zijn snel, goedkoop, betrouwbaar en wijzen op fouten (dus je zou veel moeten hebben als fundering), terwijl E2E tests langzaam, duur en broos/instabiel zijn (dus je zou weinig moeten hebben, gereserveerd voor kritieke flows) — wat zowel snelle feedback (van talrijke unit tests) als vertrouwen oplevert dat het hele systeem werkt (van enkele integratietests en enkele E2E tests).

Dit evenwicht is wat een testsuite zowel effectief als onderhoudsbaar maakt.

Het begrijpen van de **anti-patronen** is even waardevol: de **"ijshoorntje"** (omgekeerde pyramide, met vooral langzame E2E en handmatige tests en weinig unit tests) produceert een langzame, broze, dure, moeilijk te onderhouden testsuite — een veelgemaakte fout in de praktijk die de pyramide helpt te voorkomen.

Weten dat de meeste tests snelle unit tests moeten zijn (met langzame E2E gereserveerd voor de meest belangrijke flows) begeleidt het bouwen van een testsuite die goede dekking biedt met snelle feedback en weinig onderhoud.

Aangezien het goed structureren van een testsuite (het balanceren van dekking, snelheid en onderhoudbaarheid) belangrijk is voor effectief testen, en omdat de testpyramide het gidsen model hiervoor biedt (met zijn rationale en de anti-patronen om te vermijden), is het begrijpen van de testpyramide waardevol, praktisch-relevant kennis — een fundamenteel model voor gezonde teststrategie dat het bouwen van efficiënte, onderhoudbare testsuites begeleidt en het veelgemaakte fout van overmatig vertrouwen op langzame, broze tests op hoog niveau vermijdt, belangrijk voor iedereen die ontwerpt hoe een project zijn software test.