Vad är integrationstestning?

Question

Accepted Answer

**Integrationstestning** verifierar att flera **komponenter eller enheter fungerar korrekt tillsammans** — testning av interaktioner och integrationspunkter (som kod med en databas, tjänster som anropar varandra, eller kombinerade moduler). Det fångar problem som enhetstester (som isolerar enheter) missar.

## Vad integrationstestning verifierar

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

## Varför integrationstester är viktiga (jämfört 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.
```

## Exempel och överväganden

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

## Varför det spelar roll

Att förstå integrationstestning är viktigt eftersom det **fångar en klass av buggar som enhetstester inte kan** — problem i hur komponenter fungerar tillsammans — så det är värdefull kunskap för omfattande testning.

Med enhetstester verifieras enskilda enheter isolerat (genom att mocka beroenden), men denna isolering betyder att de **inte kan verifiera verklig integration**: en enhet kan klara alla sina tester men misslyckas när den faktiskt kombineras med andra (på grund av fel antaganden om ett beroende, en felaktig databasfråga, en API-kontraktmatchning eller konfigurationsproblem). **Integrationstester** fyller detta gap genom att testa **komponenter som fungerar tillsammans med verkliga (eller realistiska) beroenden** — verifiera att kod faktiskt fungerar med en verklig databas, att tjänster interagerar korrekt, och att integrationspunkter fungerar — fångande lednings-, datalager- och kontraktbuggar som isolerade enhetstester missar.

Att förstå denna komplementära relation (enhetstester för isolerad logik, integrationstester för verkliga interaktioner) är nyckeln till omfattande testning, eftersom ingen av dem ensam är tillräcklig.

Att förstå **övervägandena** — att integrationstester är långsammare (verklig I/O och konfiguration, så de sitter i mitten av pyramiden med färre än enhetstester), använder testdatabaser/miljöer, fokuserar på viktiga integrationspunkter (dataåtkomst, nyckelinteraktioner mellan tjänster, API:er), och kräver noggrann testdatahantering och tillståndshantering — återspeglar praktisk integrationstestning.

Integrationstester ger förtroende för att de samlade delarna fungerar, vilket enhetstester ensamma inte kan ge.

Eftersom verkliga applikationer består av interagerande komponenter och integrationsbuggar (databasproblem, kontraktmatchningar, konfigurationsfel) är vanliga och missas av enhetstester, och eftersom integrationstestning fångar dem genom att verifiera att komponenter fungerar tillsammans, är förståelse för integrationstestning värdefull, praktiskt relevant kunskap — ett väsentligt komplement till enhetstestning som fångar interaktionsbuggar, viktigt för omfattande testning som verifierar inte bara isolerade enheter utan att systemets delar faktiskt fungerar tillsammans korrekt.