Hvad er assertions i testing?

Question

IT Interview Practice · 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.

Hvad assertions gør

Almindelige assertion-typer

Gode assertions

Hvorfor det betyder noget

Relaterede spørgsmål