X'inhu integration testing?

Question

Accepted Answer

**Integration testing** jivverifika li multipli **komponenti jew unitajiet jaħdmu kollha flimkien b'mod korrett** — jittestja l-interazzjonijiet u l-punti ta' integrazzjoni (bħal kod ma' database, servizzi jissibu lil xulxin, jew moduli magħqudin). Tqabbad problemi li unit tests (li jizolwa l-unitajiet) jissu.

## X'jivverifiká integration testing

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

## Għaliex integration tests huma importanti (versus unit tests)

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

## Eżempju u konsiderazzjonijiet

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

## Għaliex hija importanti

Fhim ta' integration testing huwa importanti għax **jaqbad klassi ta' bugs li unit tests ma jistgħux** — problemi f'kif il-komponenti jaħdmu flimkien — allura huwa għarfien ta' valur għall-testing komprensiv.

Billi unit tests jivverifikaw unitajiet individwali b'iżolazzjoni (jirriflettaw dipendenti), din l-iżolazzjoni tfisser li **ma jistgħux jivverifikaw integrazzjoni reali**: unit jista' jgħaddi l-tests kollha tiegħu imma jfalli meta attwalment jingħaqqad ma' oħrajn (minħabba suppożizzjonijiet ħati dwar dipendenza, query ta' database reali li tkun ħati, mismatch ta' kontrattu ta' API, jew problemi ta' konfigurazzjoni). **Integration tests** jimplew dan il-vojt billi jittestjaw **komponenti li jaħdmu flimkien ma' dipendenti reali (jew realistiċi)** — jivverifikaw li kod attwalment jaħdem ma' database reali, li servizzi jinteraġixxu b'mod korrett, u li punti ta' integrazzjoni jiffunzjonaw — jaqbdu l-bugs ta' wiring, data-layer, u kontrattu li isolated unit tests jissu.

Fhim ta' din ir-relazzjoni komplementari (unit tests għal logika iżolata, integration tests għal interazzjonijiet reali) huwa essenzjali għal testing komprensiv, billi la waħda biss hija suffiċjenti.

Fhim tal-**konsiderazzjonijiet** — li integration tests huma aktar bilenti (I/O reali u setup, allura jinsabu fin-nofs tal-piramida b'inqas minn unit tests), juża test databases/ambjenti, jiffokus fuq punti importanti ta' integrazzjoni (aċċess ta' data, interazzjonijiet ewlenin ta' servizzi, APIs), u jeħtieġ ġestjoni attenta ta' test data/stat — jirifletti integration testing prattiku.

Integration tests jipprovdu kunfidenza li l-partijiet assemblati jaħdmu, li unit tests biss ma jistgħux jagħtu.

Billi applikazzjonijiet reali huma magħmula minn komponenti interaġenti u integration bugs (problemi ta' database, mismatch ta' kontrattu, erruri ta' konfigurazzjoni) huma komuni u jissu minn unit tests, u billi integration testing jaqbad dawn billi jivverifika li komponenti jaħdmu flimkien, fhim ta' integration testing huwa għarfien ta' valur u prattiku — komplement essenzjali għal unit testing li jaqbad bugs ta' interazzjoni, importanti għal testing komprensiv li jivverifika mhux biss unitajiet iżolati imma li l-partijiet tas-sistema attwalment jaħdmu flimkien b'mod korrett.