Hva er parametriserte og datadrevne tester?

Question

Accepted Answer

**Parametriserte (datadrevne) tester** kjører **samme testlogikk med flere sett med innganger og forventede utganger** — og unngår å duplisere testen for hvert tilfelle. De gjør det enkelt å teste mange scenarier (inkludert grensecaser) konsist.

## Problemet: dupliserte tester

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

## Parametriserte tester — én test, mange tilfeller

```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 rammeverk støtter dette (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Fordeler

```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 betyr noe

Å forstå parametriserte (datadrevne) tester er verdifullt fordi de gjør det **enkelt å teste mange scenarier konsist**, noe som støtter grundig testing (særlig grensecaser), så det er praktisk nyttig kunnskap.

Problemet de løser — testing av mange inngangs-/utgangskombinasjonner ville ellers kreve **duplisering av testen for hvert tilfelle** (kjedelig, repetitivt, vanskelig å vedlikeholde) — er reelt, og parametriserte tester løser det ved å kjøre **samme testlogikk over en tabell med tilfeller**.

Dette gjør testing av mange scenarier **konsist** (én testkropp, mange tilfeller), gjør det **enkelt å legge til tilfeller** (bare legg til en dataraden — noe som oppmuntrer til testing av flere innganger og **grensecaser**, som støtter grundig dekning av grensecaser som avslører feil), rapporterer **hvert tilfelle separat** (slik at du ser nøyaktig hvilken inngang som mislyktes, og det hjelper feilsøking), og holder testene vedlikeholdbare (datatabellen dokumenterer tilfellene klart).

Å forstå at de fleste rammeverk støtter dette (Jests `test.each`, pytests `@parametrize`, JUnits `@ParameterizedTest`) gjør det praktisk anvendelig på tvers av stakker.

Parametriserte tester er ideelle for funksjoner med mange inngangs-/utgangskombinasjonner — vanlig for hjelpefunksjoner, validatorer, parsere og beregninger — der de muliggjør testing av hele spekteret av tilfeller (inkludert grenser og grensecaser) uten byrden av duplisert testkode.

Denne konsise, vedlikeholdbare måten å oppnå bred inngangdekning på oppmuntrer til mer grundig testing.

Siden testing av mange scenarier (særlig grensecaser) er viktig for grundig testing og parametriserte tester gjør dette konsist og vedlikeholdt (unngår dupliserte tester, oppmuntrer til bred inngangdekning), og siden å forstå dem og deres rammeverk-støtte er nyttig for effektiv testing, er forståelse av parametriserte og datadrevne tester verdifull, praktisk relevant kunnskap — en nyttig teknikk for testing av mange tilfeller konsist, som støtter grundig dekning av grensecaser som effektiv testing krever, og et hendig verktøy som brukes hvor funksjoner har mange inngangs-/utgangskombinasjonner som skal verifiseres.