Ce este testarea de integrare?

Question

Accepted Answer

**Testarea de integrare** verifică că mai **multe componente sau unități funcționează corect împreună** — testând interacțiunile și punctele de integrare (cum ar fi codul cu o bază de date, servicii care se apelează reciproc, sau module combinate). Captează problemele pe care testele unitare (care izolează unitățile) le omit.

## Ce verifică testarea de integrare

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

## De ce contează testele de integrare (vs testele unitare)

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

## Exemplu și considerații

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

## De ce conteaza

Înțelegerea testării de integrare este importantă deoarece **captează o clasă de bug-uri pe care testele unitare nu le pot depista** — probleme în modul în care componentele funcționează împreună — deci este o cunoaștere valoroasă pentru testarea cuprinzătoare.

In timp ce testele unitare verifică unitățile individuale în izolare (mock-ând dependențele), această izolare înseamnă că **nu pot verifica integrarea reală**: o unitate poate trece toate testele sale, dar eșua atunci când este efectiv combinată cu altele (din cauza unor presupuneri greșite despre o dependență, o interogare reală a bazei de date fiind incorectă, o nepotrivire de contract API, sau probleme de configurare). **Testele de integrare** completează această lacună prin testarea **componentelor care funcționează împreună cu dependențe reale (sau realiste)** — verificând că codul funcționează cu o bază de date reală, că serviciile interacționează corect, și că punctele de integrare funcționează — captând bug-urile de cablare, layer-ul de date, și contract-urile pe care testele unitare izolate le omit.

Înțelegerea acestei relații complementare (teste unitare pentru logica izolată, teste de integrare pentru interacțiuni reale) este esențială pentru testarea cuprinzătoare, deoarece nici una singură nu este suficientă.

Înțelegerea **considerațiilor** — că testele de integrare sunt mai lente (I/O real și setup, deci se situează în mijlocul piramidei cu mai puține decât testele unitare), folosesc baze de date/medii de test, se concentrează pe punctele de integrare importante (acces la date, interacțiuni cheie între servicii, API-uri), și necesită gestionare atentă a datelor de test/stării — reflectă practica testării de integrare.

Testele de integrare oferă încrederea că părțile asamblate funcționează, ceea ce testele unitare singure nu pot oferi.

Deoarece aplicațiile reale sunt compuse din componente care interacționează și bug-urile de integrare (probleme de bază de date, nepotriviri de contract, erori de configurare) sunt frecvente și omise de testele unitare, și deoarece testarea de integrare le captează prin verificarea că componentele funcționează împreună, înțelegerea testării de integrare este o cunoaștere valoroasă, relevant din punct de vedere practic — un complement esențial pentru testarea unitară care captează bug-uri de interacțiune, important pentru testarea cuprinzătoare care verifică nu doar unitățile izolate, ci și că părțile sistemului funcționează efectiv corect împreună.