Integration testing क्या है?

Question

Accepted Answer

**Integration testing** यह सत्यापित करती है कि कई **components या units एक साथ सही ढंग से काम करते हैं** — interactions और integration points का परीक्षण करना (जैसे database के साथ code, एक-दूसरे को call करने वाली services, या संयुक्त modules)। यह उन समस्याओं को पकड़ती है जिन्हें unit tests (जो units को isolate करते हैं) चूक जाते हैं।

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

## Integration tests क्यों मायने रखते हैं (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.
```

## उदाहरण और विचारणीय बातें

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

## यह क्यों महत्वपूर्ण है

Integration testing को समझना महत्वपूर्ण है क्योंकि यह **bugs के एक वर्ग को पकड़ती है जिसे unit tests नहीं पकड़ सकते** — components के साथ काम करने के तरीके में समस्याएँ — इसलिए यह व्यापक testing के लिए मूल्यवान ज्ञान है।

जबकि unit tests अलग-अलग units को isolation में सत्यापित करते हैं (dependencies को mock करते हुए), इस isolation का अर्थ है कि वे **वास्तविक integration को सत्यापित नहीं कर सकते**: एक unit अपने सभी tests pass कर सकता है लेकिन वास्तव में दूसरों के साथ संयुक्त होने पर विफल हो सकता है (एक dependency के बारे में गलत धारणाओं, एक वास्तविक database query के गलत होने, एक API contract बेमेल, या configuration समस्याओं के कारण)। **Integration tests** इस अंतराल को **components के वास्तविक (या यथार्थवादी) dependencies के साथ एक साथ काम करने** का परीक्षण करके भरते हैं — यह सत्यापित करते हुए कि code वास्तव में एक वास्तविक database के साथ काम करता है, कि services सही ढंग से interact करती हैं, और कि integration points काम करते हैं — उन wiring, data-layer, और contract bugs को पकड़ते हुए जिन्हें isolated unit tests चूक जाते हैं।

इस पूरक संबंध को समझना (isolated logic के लिए unit tests, वास्तविक interactions के लिए integration tests) व्यापक testing के लिए महत्वपूर्ण है, क्योंकि अकेले कोई भी पर्याप्त नहीं है।

**विचारणीय बातों** को समझना — कि integration tests धीमे होते हैं (वास्तविक I/O और setup, इसलिए वे pyramid के बीच में unit tests से कम के साथ बैठते हैं), test databases/environments का उपयोग करते हैं, महत्वपूर्ण integration points पर ध्यान केंद्रित करते हैं (data access, मुख्य service interactions, APIs), और सावधानीपूर्वक test data/state प्रबंधन की आवश्यकता होती है — व्यावहारिक integration testing को दर्शाता है।

Integration tests यह विश्वास प्रदान करते हैं कि संयुक्त हिस्से काम करते हैं, जो अकेले unit tests नहीं दे सकते।

चूँकि वास्तविक applications interacting components से बने होते हैं और integration bugs (database समस्याएँ, contract बेमेल, configuration errors) सामान्य हैं और unit tests द्वारा चूक जाते हैं, और चूँकि integration testing components के एक साथ काम करने को सत्यापित करके उन्हें पकड़ती है, integration testing को समझना मूल्यवान, व्यावहारिक रूप से प्रासंगिक ज्ञान है — unit testing का एक आवश्यक पूरक जो interaction bugs पकड़ता है, व्यापक testing के लिए महत्वपूर्ण जो न केवल isolated units बल्कि यह सत्यापित करता है कि प्रणाली के हिस्से वास्तव में एक साथ सही ढंग से काम करते हैं।