integration testing என்றால் என்ன?

Question

Accepted Answer

**Integration testing** பல **கூறுகள் அல்லது அலகுகள் சேர்ந்து சரியாக செயல்படுகின்றனவா** என்பதை சரிபார்க்கிறது — தொடர்புகள் மற்றும் integration points (குறியீடு ஒரு தரவுத்தளத்துடன், சேவைகள் ஒருவருக்கொருவர் அழைக்கும் போது, அல்லது மாடியூல்கள் இணைக்கப்பட்டிருக்கும் போது போன்ற) சோதனை செய்கிறது. Unit tests (இவை அலகுகளை தனிமைப்படுத்தும்) தவறவிட்ட சிக்கல்களைப் பிடிக்கிறது.

## 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 ஐ புரிந்துகொள்வது முக்கியம் என்ற காரணம் அது **unit tests க்கு பிடிக்க முடியாத பிழைகளின் வர்க்கத்தைப் பிடிக்கிறது** — கூறுகள் சேர்ந்து எவ்வாறு செயல்படுகின்றன என்பதில் உள்ள சிக்கல்கள் — அதனால் இது comprehensive testing க்கான மதிப்புள்ள அறிவு.

Unit tests தனிமைப்படுத்தப்பட்ட வகையில் தனிப்பட்ட அலகுகளை சரிபார்க்கிறது (dependencies ஐ mock செய்து), இந்த தனிமைப்படுத்தல் **உண்மையான integration ஐ சரிபார்க்க முடியாது** என்று அর்த்தமாகிறது: ஒரு அலகு அதன் அனைத்து tests ஐ pass செய்யலாம் ஆனால் உண்மையாக மற்றவற்றுடன் இணைக்கப்பட்டபோது தோல்வியடையலாம் (ஒரு dependency பற்றி தவறான அனுமான கள், ஒரு உண்மையான தரவுத்தள query தவறாக இருப்பதாக, ஒரு API contract mismatch அல்லது configuration சிக்கல்கள் காரணமாக). **Integration tests** இந்த இடைவெளியை நிரப்புகின்றன **உண்மையான (அல்லது யதார்த்தமான) dependencies உடன் சேர்ந்து கூறுகளைச் சோதனை** செய்வதன் மூலம் — குறியீடு உண்மையான தரவுத்தளத்துடன் உண்மையாக சேர்ந்து செயல்படுகிறதா, சேவைகள் சரியாக தொடர்புகொள்கின்றனவா, மற்றும் integration points செயல்படுகின்றனவா என்பதை சரிபார்க்கிறது — wiring, data-layer, மற்றும் contract பிழைகளைப் பிடிக்கிறது அவை தனிமைப்படுத்தப்பட்ட unit tests தவிர்க்கின்றன.

இந்த complementary உறவைப் புரிந்துகொள்வது (தனிமைப்படுத்தப்பட்ட தர்க்கத்திற்கான unit tests, உண்மையான தொடர்புகளுக்கான integration tests) comprehensive testing க்கு விசையாகும், ஆனந்தம் தனியாக மட்டும் போதுமானது அல்ல.

இந்த **கருத்தில் கொள்ளவேண்டிய விஷயங்களை** புரிந்துகொள்வது — integration tests கட்டம்பாடு இருக்கின்றன (உண்மையான I/O மற்றும் setup, அதனால் அவை pyramid ஐ உங்கள் நடுவில் உட்கார்ந்திருக்கின்றன unit tests ஐ விட குறைவாக), test தரவுத்தளங்கள்/சூழல்களைப் பயன்படுத்துகின்றன, முக்கியமான integration points (data access, முக்கிய சேவை தொடர்புகள், APIs) க்கு கவனம் செலுத்துகின்றன, மற்றும் test தரவு/state மேலாண்மை சாবாசாக வேண்டும் — பரிபாலன integration testing ஐ பிரதிபலிக்கிறது.

Integration tests கூட்டிய பகுதிகள் செயல்படுகிறது என்ற நம்பிக்கை வழங்குகிறது, அதை unit tests தனியாக கொடுக்க முடியாது.

உண்மையான applications தொடர்பு கொண்ட கூறுகளால் ஆனவை மற்றும் integration பிழைகள் (தரவுத்தள சிக்கல்கள், contract mismatches, configuration errors) பொதுவாக மற்றும் unit tests மூலம் தவிர்க்கப்படுகின்றன, மற்றும் integration testing அவற்றைப் பிடிக்கிறது கூறுகள் சேர்ந்து செயல்படுகிறது என்பதை சரிபார்க்கிறது, integration testing ஐ புரிந்துகொள்வது மதிப்புள்ள, பரிபாலனை-பொருந்தும் அறிவு — ஒரு அத்தியாவசிய supplement unit testing க்கு பிழைத்தோராய வேட்டை பிடிக்கிறது, comprehensive testing க்கு முக்கியம் அது சரிபார்க்கிறது தனிப்பட்ட அலகுகள் மட்டுமல்ல ஆனால் அந்த system ஈ பகுதிகள் உண்மையாக சேர்ந்து சரியாக செயல்படுகின்றன.