Wat zijn assertions in testen?

Question

Accepted Answer

**Assertions** zijn statements in een test die **controleren of een voorwaarde waar is** — verifiëren dat het werkelijke resultaat overeenkomt met het verwachte resultaat. Ze vormen de kern van hoe tests bepalen of ze slagen of falen: als een assertion faalt, faalt de test.

## Wat assertions doen

```text
An ASSERTION checks that something is as expected:
  → "assert that the actual value EQUALS the expected value"
  → if TRUE → the assertion passes; if FALSE → the assertion FAILS → the TEST FAILS
→ Assertions are how a test VERIFIES behavior (the "check" part of a test).
```

## Veelvoorkomende assertion-typen

```js
// equality
expect(result).toBe(5);                  // strict equality
expect(obj).toEqual({ name: 'Ann' });    // deep/value equality (objects)

// truthiness / null
expect(value).toBeTruthy();
expect(value).toBeNull();
expect(value).toBeDefined();

// comparisons
expect(count).toBeGreaterThan(0);
expect(price).toBeLessThanOrEqual(100);

// collections / strings
expect(array).toContain('item');
expect(array).toHaveLength(3);
expect(text).toMatch(/pattern/);          // regex

// errors
expect(() => risky()).toThrow();          // expect a function to throw

// negation
expect(value).not.toBe(null);
```

## Goede assertions

```text
✓ Assert the SPECIFIC expected outcome (clear what's being checked)
✓ Use the RIGHT matcher (toBe vs toEqual; specific > generic)
✓ Clear FAILURE messages (good assertions/matchers explain what failed)
✓ Don't over-assert (test one behavior) or under-assert (verify the actual result)
```

## Waarom het belangrijk is

Assertions begrijpen is fundamenteel omdat ze **het kernmechanisme zijn waarmee tests gedrag verifiëren** — bepalen of iets slaagt of faalt — dus het is essentieel, onmisbaar kennis voor het schrijven van elke test.

Een assertion **controleert of een voorwaarde waar is** (doorgaans dat een werkelijk resultaat overeenkomt met een verwacht resultaat), en het is het "verificatie"-gedeelte van een test: als een assertion de controle doorstaat, geldt het, en als deze faalt, faalt de test.

Zonder assertions verifieert een test eigenlijk niets — dus het begrijpen ervan is fundamenteel voor het schrijven van betekenisvolle tests.

De **veelvoorkomende assertion-typen** begrijpen — gelijkheid (strikte `toBe` vs diepe/waarde `toEqual` voor objecten, een belangrijk onderscheid), waarheidsgetrouwheid en null-controles, vergelijkingen, verzameling- en string-controles, error-assertions (verifiëren dat een functie een exception gooit), en negatie — is noodzakelijke praktische kennis voor het uitdrukken wat een test moet verifiëren.

De **goede assertion-praktijken** begrijpen — het specifieke verwachte resultaat asserteren (duidelijk over wat wordt gecontroleerd), de juiste matcher gebruiken (bijvoorbeeld `toEqual` voor objectvergelijking, niet `toBe`), duidelijke foutmeldingen garanderen (zodat een falende test uitlegt wat fout ging), en assertions balanceren (één gedrag testen, maar het werkelijke resultaat verifiëren) — weerspiegelt het schrijven van heldere, effectieve tests.

Omdat assertions hoe elke test gedrag verifieert (de fundamentele controle die een test betekenisvol maakt) en ze begrijpen — de typen, de juiste matchers, en goede praktijken — noodzakelijk is om elke test te schrijven die werkelijk iets verifieert, is het begrijpen van assertions essentiële, fundamentele test-kennis — het kernbouwsteen van tests, noodzakelijk voor het uitdrukken en verifiëren van verwacht gedrag, en fundamenteel voor het schrijven van tests die op betekenisvolle wijze juistheid controleren, een basiscompetentie voor iedereen die tests schrijft.