Hvad er integrationstestning?

Question

Accepted Answer

**Integrationstestning** bekræfter, at flere **komponenter eller enheder fungerer korrekt sammen** — testning af interaktioner og integrationspunkter (som kode med en database, services der kalder hinanden, eller moduler kombineret). Det fanger problemer, som unit tests (som isolerer enheder) misser.

## Hvad integrationstestning bekræfter

```text
Integration tests verify COMPONENTS WORKING TOGETHER (not in isolation):
  → code + DATABASE (does the data layer actually work with a real DB?)
  → service A calling service B / an external API
  → multiple modules/units combined; the integration POINTS between them
→ catches issues in how parts INTERACT — which unit tests (isolated) can't catch.
```

## Hvorfor integrationstests betyder noget (sammenlignet med unit tests)

```text
UNIT tests isolate units (mocking dependencies) → fast, but DON'T verify real integration:
  → a unit can pass its tests but FAIL when combined (wrong assumptions about a dependency,
    a real DB query that's wrong, an API contract mismatch, config issues)
INTEGRATION tests use REAL (or realistic) dependencies → catch these interaction bugs:
  → wiring/configuration errors, data layer issues, contract mismatches between components
→ Integration tests verify the parts actually work TOGETHER.
```

## Eksempel og overvejelser

```js
// integration test: the repository actually works with a (test) database
test('UserRepository saves and retrieves a user', async () => {
  const repo = new UserRepository(testDb);     // REAL test database
  await repo.save({ name: 'Ann' });
  const user = await repo.findByName('Ann');    // real query
  expect(user.name).toBe('Ann');
});
```

```text
→ SLOWER than unit tests (real I/O, setup); use a TEST database/environment
→ Test important integration points (data access, key service interactions, APIs)
→ Fewer than unit tests (the pyramid middle); manage test data/state carefully
```

## Hvorfor det betyder noget

At forstå integrationstestning er vigtigt, fordi det **fanger en klasse af fejl, som unit tests ikke kan** — problemer i hvordan komponenter arbejder sammen — så det er værdifuld viden for omfattende testning.

Mens unit tests bekræfter individuelle enheder isoleret (ved at mocke afhængigheder), betyder denne isolation, at de **ikke kan bekræfte rigtig integration**: en enhed kan bestå alle sine tests, men fejle når den faktisk kombineres med andre (på grund af forkerte antagelser om en afhængighed, en rigtig databaseforespørgsel der er forkert, et API-kontraktmismatch, eller konfigurationsproblemer). **Integrationstests** udfylder denne gap ved at teste **komponenter der arbejder sammen med rigtige (eller realistiske) afhængigheder** — bekræftelse af at kode faktisk fungerer med en rigtig database, at services interagerer korrekt, og at integrationspunkter fungerer — fangning af lednings-, datalaags- og kontraktfejl, som isolerede unit tests misser.

At forstå dette komplementære forhold (unit tests til isoleret logik, integrationstests til rigtig interaktion) er nøgle til omfattende testning, da ingen af dem alene er tilstrækkelig.

At forstå **overvejelserne** — at integrationstests er langsommere (rigtig I/O og opsætning, så de sidder i midten af pyramiden med færre end unit tests), bruger testdatabaser/miljøer, fokuserer på vigtige integrationspunkter (dataadgang, vigtige serviceinteraktioner, APIs), og kræver omhyggelig testdata/tilstandsstyring — afspejler praktisk integrationstestning.

Integrationstests giver tillid til, at de samlede dele fungerer, hvilket unit tests alene ikke kan give.

Da rigtige applikationer består af interagerende komponenter, og integrationsfejl (databaseproblemer, kontraktmismatches, konfigurationsfejl) er almindelige og misses af unit tests, og da integrationstestning fanger dem ved at bekræfte at komponenter fungerer sammen, er forståelse af integrationstestning værdifuld, praktisk relevant viden — et væsentligt supplement til unit testing, der fanger interaktionsfejl, vigtig for omfattende testning, der bekræfter ikke blot isolerede enheder, men at systemets dele faktisk fungerer sammen korrekt.