Wat is unit testen?

Question

Wat is unit testen?

Accepted Answer

**Unit testen** verifieert individuele **units** van code (functies, methoden, klassen) in **isolatie** — controleerend dat elk klein stukje correct op zichzelf werkt. Unit tests zijn snel, gericht, en vormen de basis van een goede teststrategie.

## Wat een unit test is

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

## Voorbeeld

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

## Karakteristieken van goede unit tests

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

## Waarom het belangrijk is

Unit testen begrijpen is fundamenteel omdat **unit tests de basis vormen van een goede teststrategie** — de basis van de testpiramide — dus het is essentieel, moet-weten kennis.

Een unit test verifieert het **kleinste testbare stukje code (een functie of methode) in isolatie**, controleerend dat het correct werkt op zichzelf met gegeven invoer die verwachte uitvoer produceert.

Dit begrijpen — één ding tegelijk testen, geïsoleerd van afhankelijkheden (mocking externe systemen zoals databases en netwerken), snel en deterministisch — is de kern van unit testen.

Unit tests zijn waardevol omdat zij **snel** zijn (draaiend in milliseconden, dus je kunt veel frequent uitvoeren voor snelle feedback), **gericht** (precies aanwijzend wat kapot ging wanneer zij falen), en vormen de **basis** waaruit het meeste van een testsuite zou moeten bestaan.

De **karakteristieken van goede unit tests** begrijpen — snel, geïsoleerd (mocking afhankelijkheden, onafhankelijk van andere tests), deterministisch (geen flakiness), gedrag en resultaten testend (niet implementatiedetails, dus tests breken niet bij refactoring), en normale gevallen, edge cases, en foutcondities dekkend — is belangrijk voor het schrijven van effectieve tests die echte waarde bieden in plaats van broze of lage-waarde testen.

Unit testen is de meest voorkomende en fundamentele vorm van testen, centraal aan TDD, CI/CD, en zelfverzekerde ontwikkeling.

Omdat unit tests de basis van testen vormen (de basis van de piramide, de meest talrijke en meest uitgevoerde tests) en begrijpen wat zij zijn en hoe goede testen te schrijven (geïsoleerd, snel, gericht, gedrag testend) essentieel is voor elke teststrategie, is unit testen begrijpen essentiële, fundamentele kennis — de hoeksteen van softwaretesten die elke ontwikkelaar zou moeten begrijpen en toepassen, fundamenteel voor het verifiëren van codecorrectheid en het ermögelijken van de zelfverzekerde, veilige ontwikkeling die goed testen biedt.