Hvad er assertions i testing?

Question

Accepted Answer

**Assertions** er udsagn i en test, der **kontrollerer, om en betingelse er sand** — de verificerer, at det faktiske resultat matcher det forventede resultat. De er kernen i, hvordan tests bestemmer pass eller fail: hvis en assertion fejler, fejler testen.

## Hvad assertions gø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).
```

## Almindelige 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 betyder noget

At forstå assertions er grundlæggende, fordi de er **kernemekanismen, hvorved tests verificerer adfærd** — de bestemmer pass eller fail — så det er væsentlig, må-vide viden for at skrive nogen test.

En assertion **kontrollerer, at en betingelse er sand** (typisk at et faktisk resultat matcher et forventet), og det er "verificerings"-delen af en test: hvis en assertion består, holder kontrollen, og hvis den fejler, fejler testen.

Uden assertions verificerer en test faktisk ikke noget — så at forstå dem er grundlæggende for at skrive meningsfulde tests.

At forstå **almindelige assertion-typer** — lighed (streng `toBe` vs dyb/værdi `toEqual` for objekter, en vigtig forskel), sandhedsværdi og null-kontroller, sammenligninger, samling og strengkontroller, error assertions (verificering af, at en funktion kaster), og negation — er nødvendig praktisk viden for at udtrykke, hvad en test skal verificere.

At forstå **gode assertion-praksis** — at hævde det specifikke forventede resultat (klart om hvad der kontrolleres), bruge den rigtige matcher (f.eks. `toEqual` til objektsammenligning, ikke `toBe`), sikre klare fejlmeddelelser (så en fejlende test forklarer, hvad der gik galt), og balancere assertions (teste en adfærd, men verificere det faktiske resultat) — afspejler skrivelse af klare, effektive tests.

Da assertions er, hvordan enhver test verificerer adfærd (den grundlæggende kontrol, der gør en test meningsfuld) og at forstå dem — typerne, de rigtige matchere og gode praksis — er nødvendig for at skrive nogen test, der faktisk verificerer noget, er forståelsen af assertions væsentlig, grundlæggende testningsviden — kernebyggestenen i tests, nødvendig for at udtrykke og verificere forventet adfærd, og grundlæggende for at skrive tests, der meningsfuldt kontrollerer korrekthed, en grundlæggende kompetence for alle, der skriver tests.