Hva er integrasjonstesting?

Question

Accepted Answer

**Integrasjonstesting** verifiserer at flere **komponenter eller enheter fungerer korrekt sammen** — testing av interaksjonene og integrasjonspunktene (som kode med en database, tjenester som kaller hverandre, eller moduler kombinert). Det fanger opp problemer som enhetstester (som isolerer enheter) mister.

## Hva integrasjonstesting verifiserer

```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 integrasjonstester er viktige (sammenlignet med enhetstester)

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

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

Å forstå integrasjonstesting er viktig fordi det **fanger en klasse av feil som enhetstester ikke kan** — problemer i hvordan komponenter fungerer sammen — så det er verdifull kunnskap for omfattende testing.

Mens enhetstester verifiserer individuelle enheter isolert (mock-dependency), betyr denne isolasjonen at de **ikke kan verifisere reell integrasjon**: en enhet kan bestå alle sine tester, men feile når den faktisk kombineres med andre (på grunn av feil antagelser om en dependency, en reell databasespørring som er feil, et API-kontraktmisforhold, eller konfigurasjonsutgaver). **Integrasjonstester** fyller dette gapet ved å teste **komponenter som fungerer sammen med reelle (eller realistiske) avhengigheter** — verifisering av at kode faktisk fungerer med en reell database, at tjenester samhandler korrekt, og at integrasjonspunkter fungerer — fangst av lednings-, datalaags- og kontraktfeil som isolerte enhetstester mister.

Å forstå dette komplementære forholdet (enhetstester for isolert logikk, integrasjonstester for reelle interaksjoner) er nøkkelen til omfattende testing, siden ingen av dem alene er tilstrekkelig.

Å forstå **hensynene** — at integrasjonstester er tregere (reell I/O og oppsett, så de sitter i midten av pyramiden med færre enn enhetstester), bruker testdatabaser/miljøer, fokuserer på viktige integrasjonspunkter (datakvalitet, nøkkeltjenesteinteraksjoner, API-er), og krever forsiktig testdata/statusstyring — reflekterer praktisk integrasjonstesting.

Integrasjonstester gir tillit til at de monterte delene fungerer, noe som enhetstester alene ikke kan gi.

Da reelle applikasjoner består av samvirkende komponenter og integrasjonsfeil (databaseproblem, kontraktmisforhold, konfigurasjonsutgaver) er vanlige og blir oversett av enhetstester, og siden integrasjonstesting fanger dem ved å verifisere at komponenter fungerer sammen, er forståelsen av integrasjonstesting verdifull, praktisk relevant kunnskap — et essensielt komplement til enhetstesting som fanger interaksjonsfeil, viktig for omfattende testing som verifiserer ikke bare isolerte enheter, men at systemets deler faktisk fungerer korrekt sammen.