Hva er assertions i testing?

Question

Accepted Answer

**Assertions** er utsagn i en test som **sjekker om en betingelse er sann** — og verifiserer at det faktiske resultatet samsvarer med det forventede resultatet. De er kjernen av hvordan tester bestemmer bestått eller ikke bestått: hvis en assertion mislykkes, mislykkes testen.

## Hva assertions gjør

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

## Vanlige assertion-typer

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

## Gode 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)
```

## Hvorfor det er viktig

Å forstå assertions er grunnleggende fordi de er **kjernemekanismen som tester bruker for å verifisere atferd** — som bestemmer bestått eller ikke bestått — så det er essensielt, må-vite-kunnskap for å skrive noen test.

En assertion **sjekker at en betingelse er sann** (typisk at et faktisk resultat samsvarer med et forventet), og det er "verifiseringsdelen" av en test: hvis en assertion består er kontrollen oppfylt, og hvis den mislykkes mislykkes testen.

Uten assertions verifiserer en test faktisk ingenting — så det å forstå dem er grunnleggende for å skrive meningsfulle tester.

Å forstå **vanlige assertion-typer** — likhet (streng `toBe` vs dyp/verdi `toEqual` for objekter, en viktig distinksjon), sannhetssjekker og null-sjekker, sammenligninger, samlings- og strengsjekker, error-assertions (verifisering at en funksjon kaster), og negasjon — er nødvendig praktisk kunnskap for å uttrykke hva en test skal verifisere.

Å forstå **gode assertion-praksiser** — å sjekke det spesifikke forventede utfallet (tydelig om hva som sjekkes), bruke riktig matcher (f.eks. `toEqual` for objektsammenligning, ikke `toBe`), sikre klare feilmeldinger (slik at en mislykket test forklarer hva som gikk galt), og balansere assertions (teste en atferd, men verifisere det faktiske resultatet) — gjenspeiler å skrive klare, effektive tester.

Siden assertions er hvordan hver test verifiserer atferd (den grunnleggende kontrollen som gjør en test meningsfull) og det å forstå dem — typene, de rette matcherne, og gode praksiser — er nødvendig for å skrive noen test som faktisk verifiserer noe, er forståelse av assertions essensielt, grunnleggende testing-kunnskap — byggeklossen for tester, nødvendig for å uttrykke og verifisere forventet atferd, og grunnleggende for å skrive tester som meningsfylt sjekker korrekthet, en grunnleggende kompetanse for alle som skriver tester.