Che cos'è il testing di integrazione?

Question

IT Interview Practice · 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.

Cosa verifica il testing di integrazione

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

Esempio e considerazioni

Perché è importante

Domande correlate