Che cos'è il testing di integrazione?

Question

Accepted Answer

**Il testing di integrazione** verifica che molteplici **componenti o unità funzionino correttamente insieme** — testando le interazioni e i punti di integrazione (come il codice con un database, servizi che si chiamano l'un l'altro, o moduli combinati). Rileva problemi che i test unitari (che isolano le unità) non riescono a catturare.

## Cosa verifica il testing di integrazione

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

## Perché i test di integrazione sono importanti (vs test unitari)

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

## Esempio e considerazioni

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

## Perché è importante

Comprendere il testing di integrazione è importante perché **rileva una classe di bug che i test unitari non possono catturare** — problemi nel modo in cui i componenti lavorano insieme — quindi è una conoscenza preziosa per un testing completo.

Mentre i test unitari verificano singole unità in isolamento (mockando le dipendenze), questo isolamento significa che **non possono verificare la vera integrazione**: un'unità può passare tutti i suoi test ma fallire quando effettivamente combinata con altre (a causa di supposizioni errate su una dipendenza, una vera query al database scorretta, una mancata corrispondenza nel contratto dell'API, o problemi di configurazione). **I test di integrazione** colmano questo divario testando **componenti che lavorano insieme con dipendenze reali (o realistiche)** — verificando che il codice funziona effettivamente con un database reale, che i servizi interagiscono correttamente, e che i punti di integrazione funzionano — catturando i bug di cablaggio, del livello dati e del contratto che i test unitari isolati non rilevano.

Comprendere questa relazione complementare (test unitari per la logica isolata, test di integrazione per le interazioni reali) è fondamentale per un testing completo, poiché nessuno dei due da solo è sufficiente.

Comprendere le **considerazioni** — che i test di integrazione sono più lenti (I/O reale e setup, quindi si situano nel mezzo della piramide con meno test rispetto ai test unitari), utilizzano database/ambienti di test, si concentrano su importanti punti di integrazione (accesso ai dati, interazioni chiave tra servizi, API), e richiedono una gestione attenta dei dati di test e dello stato — riflette la pratica del testing di integrazione.

I test di integrazione forniscono la fiducia che le parti assemblate funzionino, cosa che i soli test unitari non possono garantire.

Poiché le applicazioni reali sono composte da componenti che interagiscono e i bug di integrazione (problemi di database, mancate corrispondenze di contratto, errori di configurazione) sono comuni e non rilevati dai test unitari, e poiché il testing di integrazione li cattura verificando che i componenti funzionino insieme, comprendere il testing di integrazione è una conoscenza preziosa e praticamente rilevante — un complemento essenziale al testing unitario che cattura i bug di interazione, importante per un testing completo che verifica non solo le unità isolate ma che le parti del sistema effettivamente funzionano insieme correttamente.