Apa itu integration testing?

Question

Accepted Answer

**Integration testing** memverifikasi bahwa **multiple components atau units bekerja dengan benar bersama-sama** — menguji interaksi dan integration points (seperti code dengan database, services memanggil satu sama lain, atau modules yang dikombinasikan). Integration testing menangkap issues yang unit tests (yang mengisolasi units) lewatkan.

## Apa yang diverifikasi 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.
```

## Mengapa integration tests penting (vs 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.
```

## Contoh dan pertimbangan

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

## Mengapa ini penting

Memahami integration testing penting karena **menangkap class of bugs yang unit tests tidak bisa** — issues dalam bagaimana components bekerja bersama — sehingga ini merupakan pengetahuan yang berharga untuk comprehensive testing.

Sementara unit tests memverifikasi individual units dalam isolasi (mocking dependencies), isolasi ini berarti mereka **tidak bisa memverifikasi real integration**: sebuah unit dapat lulus semua testnya tetapi gagal ketika benar-benar dikombinasikan dengan yang lain (karena asumsi salah tentang dependency, real database query yang tidak benar, API contract mismatch, atau issues konfigurasi). **Integration tests** mengisi gap ini dengan menguji **components bekerja bersama dengan real (atau realistic) dependencies** — memverifikasi bahwa code benar-benar bekerja dengan real database, bahwa services berinteraksi dengan benar, dan bahwa integration points berfungsi — menangkap wiring, data-layer, dan contract bugs yang isolated unit tests lewatkan.

Memahami complementary relationship ini (unit tests untuk isolated logic, integration tests untuk real interactions) adalah key untuk comprehensive testing, karena tidak ada yang cukup sendiri.

Memahami **considerations** — bahwa integration tests lebih lambat (real I/O dan setup, jadi mereka berada di tengah pyramid dengan lebih sedikit daripada unit tests), menggunakan test databases/environments, fokus pada important integration points (data access, key service interactions, APIs), dan memerlukan careful test data/state management — mencerminkan practical integration testing.

Integration tests memberikan confidence bahwa assembled parts bekerja, yang unit tests sendiri tidak bisa berikan.

Karena real applications terdiri dari interacting components dan integration bugs (database issues, contract mismatches, configuration errors) adalah common dan missed oleh unit tests, dan karena integration testing menangkapnya dengan memverifikasi components bekerja bersama, memahami integration testing adalah valuable, practically-relevant knowledge — essential complement terhadap unit testing yang menangkap interaction bugs, penting untuk comprehensive testing yang memverifikasi bukan hanya isolated units tetapi bahwa system's parts benar-benar bekerja bersama dengan benar.