Hvad er enhedstestning?

Question

Accepted Answer

**Enhedstestning** verificerer individuelle **enheder** af kode (funktioner, metoder, klasser) i **isolation** — kontrollerer, at hver lille del fungerer korrekt på egen hånd. Enhedstests er hurtige, fokuserede og danner grundlaget for en god teststrategi.

## Hvad en enhedstest er

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Eksempel

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Karakteristika ved gode enhedstests

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Hvorfor det betyder noget

At forstå enhedstestning er grundlæggende, fordi **enhedstests er grundlaget for en god teststrategi** — bunden af testpyramiden — så det er vigtig, must-know viden.

En enhedstest verificerer det **mindste testbare stykke kode (en funktion eller metode) i isolation**, kontrollerer, at det fungerer korrekt på egen hånd med givne inputs, der producerer forventede outputs.

At forstå dette — teste en ting ad gangen, isoleret fra afhængigheder (mocking eksterne systemer som databaser og netværk), hurtigt og deterministisk — er kernen i enhedstestning.

Enhedstests er værdifulde, fordi de er **hurtige** (kører på millisekunder, så du kan køre mange hyppigt for hurtig feedback), **fokuserede** (peger præcist på hvad der gik galt, når de fejler), og danner **grundlaget**, som det meste af en testsuite bør bestå af.

At forstå **karakteristika ved gode enhedstests** — hurtige, isolerede (mocking afhængigheder, uafhængige af andre tests), deterministiske (ingen skrøbelighed), teste adfærd og resultater (ikke implementeringsdetaljer, så tests ikke bryder ved refaktorering), og dække normale tilfælde, randtilfælde og fejltilstande — er vigtig for at skrive effektive tests, der giver reel værdi snarere end skrøbelige eller lavværdi-tests.

Enhedstestning er den mest almindelige og grundlæggende form for testning, central for TDD, CI/CD og sikker udvikling.

Da enhedstests er grundlaget for testning (bunden af pyramiden, de mest talrige og hyppigst kørte tests) og at forstå hvad de er og hvordan man skriver gode (isolerede, hurtige, fokuserede, teste adfærd) er vigtig for enhver teststrategi, er forståelse af enhedstestning essentiel, grundlæggende viden — hjørnestenen i softwaretestning, som hver udvikler bør forstå og praktisere, grundlæggende for at verificere kodekorrekthed og muliggøre den sikre, tryg udvikling, som god testning giver.