Hvad er parameteriserede og datadrevne tests?

Question

Accepted Answer

**Parameteriserede (datadrevne) tests** kører **den samme testlogik med flere sæt inputs og forventede outputs** — hvilket undgår at duplikere testen for hver case. De gør det let at teste mange scenarier (herunder edge cases) kortfattet.

## Problemet: duplikerede tests

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Parameteriserede tests — én test, mange cases

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

De fleste frameworks understøtter dette (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Fordele

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## Hvorfor det betyder noget

At forstå parameteriserede (datadrevne) tests er værdifuldt, fordi de gør det **let at teste mange scenarier kortfattet**, hvilket understøtter grundig testing (især edge cases), så det er praktisk nyttig viden.

Problemet, de løser — at teste mange input/output-kombinationer ville ellers kræve **at duplikere testen for hver case** (trættende, gentagen, svær at vedligeholde) — er reelt, og parameteriserede tests løser det ved at køre **den samme testlogik over en tabel af cases**.

Dette gør testing af mange scenarier **kortfattet** (én testbrødtekst, mange cases), gør det **let at tilføje cases** (blot tilføj en datarække — hvilket tilskynder til at teste flere inputs og **edge cases**, hvilket understøtter den grundige edge-case-dækning, der fanger bugs), rapporterer **hver case separat** (så du ser præcis hvilket input, der fejlede, hvilket hjælper debugging), og holder tests vedligeholdelige (datatabellen dokumenterer klart casene).

At forstå, at de fleste frameworks understøtter dette (Jests `test.each`, pytests `@parametrize`, JUnits `@ParameterizedTest`) gør det praktisk applicable på tværs af stacks.

Parameteriserede tests er ideelle til funktioner med mange input/output-kombinationer — almindeligt for utility-funktioner, validatorer, parsere og beregninger — hvor de muliggør testing af det fulde område af cases (herunder grænser og edge cases) uden byrden af duplikeret testkode.

Denne kortfattet, vedligeholdelig måde at opnå bred input-dækning på tilskynder til mere grundig testing.

Da testing af mange scenarier (især edge cases) er vigtig for grundig testing, og parameteriserede tests gør dette kortfattet og vedligeholdelig (undgår duplikerede tests, tilskynder til bred input-dækning), og da det at forstå dem og deres framework-understøttelse er nyttigt for effektiv testing, er forståelse af parameteriserede og datadrevne tests værdifuld, praktisk relevant viden — en nyttig teknik til at teste mange cases kortfattet, understøtte den grundige edge-case-dækning, som effektiv testing kræver, og et praktisk værktøj, der anvendes, hvor funktioner har mange input/output-kombinationer at bekræfte.