Hva er enhetstesting?

Question

Accepted Answer

**Enhetstesting** verifiserer individuelle **enheter** av kode (funksjoner, metoder, klasser) **isolert** — kontrollerer at hver liten del fungerer korrekt på egen hånd. Enhetstester er raske, fokuserte og danner grunnlaget for en god testingstrategi.

## Hva en enhetstest 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);
});
```

## Karakteristikker for gode enhetstester

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

Å forstå enhetstesting er grunnleggende fordi **enhetstester er grunnlaget for en god testingstrategi** — basen av testpyramiden — så det er essensielt, nødvendig kunnskap.

En enhetstest verifiserer den **minste testbare delen av kode (en funksjon eller metode) isolert**, kontrollerer at den fungerer korrekt på egen hånd med gitte input som produserer forventet output.

Å forstå dette — teste en ting om gangen, isolert fra avhengigheter (mocking av eksterne systemer som databaser og nettverk), raskt og deterministisk — er kjernen av enhetstesting.

Enhetstester er verdifulle fordi de er **raske** (kjører på millisekunder, slik at du kan kjøre mange hyppig for raskt tilbakemelding), **fokuserte** (peker nøyaktig på hva som gikk galt når de mislykkes), og danner **grunnlaget** som det meste av en testpakke bør bestå av.

Å forstå **karakteristikkene for gode enhetstester** — raske, isolerte (mocking av avhengigheter, uavhengige av andre tester), deterministiske (ingen ustabilitet), teste atferd og resultat (ikke implementeringsdetaljer, slik at tester ikke brytes ved refaktorering), og dekke normale tilfeller, grenstilfeller og feilbetingelser — er viktig for å skrive effektive tester som gir real verdi i stedet for skjøre eller lavverdi-tester.

Enhetstesting er den vanligste og mest grunnleggende formen for testing, sentral for TDD, CI/CD og selvsikker utvikling.

Ettersom enhetstester er grunnlaget for testing (basen av pyramiden, de mest tallrike og hyppig kjørte testene) og å forstå hva de er og hvordan man skriver gode (isolerte, raske, fokuserte, testing av atferd) er essensielt for enhver testingstrategi, er forståelse av enhetstesting essensielt, grunnleggende kunnskap — hjørnestenen av programvaretesting som enhver utvikler bør forstå og praktisere, grunnleggende for å verifisere kodekorrekthet og muliggjøre den sikre, selvsikre utviklingen som god testing gir.