რა არის ინტეგრაციული ტესტირება?

Question

Accepted Answer

**ინტეგრაციული ტესტირება** ამოწმებს, რომ რამდენიმე **კომპონენტი ან ერთეული სწორად მუშაობს ერთად** — ტესტირებს ურთიერთქმედებებს და ინტეგრაციის წერტილებს (როგორიცაა კოდი მონაცემთა ბაზით, სერვისები რომლებიც ერთმეორეს იძახებენ, ან მოდულები დაკომбინებული). ის თვისებს იჭერს, რომელთა გამო ერთეული ტესტები (რომლებიც ერთეულებს იზოლირებენ) აკლდებათ.

## რა ამოწმებს ინტეგრაციული ტესტირება

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

## რატომ აქვს მნიშვნელობა ინტეგრაციული ტესტები (ერთეულის ტესტებთან შედარებით)

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

## რატომ აქვს მნიშვნელობა

ინტეგრაციული ტესტირების გაგება მნიშვნელოვანია, რადგან ის **იჭერს ხარვეზების კლასს, რომელიც ერთეული ტესტებმა ვერ შეძლებს** — პრობლემებს იმ თუ როგორ მუშაობენ კომპონენტები ერთად — ამიტომ ეს ღირებული ცოდნა ყოვლისმომცველი ტესტირებისთვის.

ხოლო ერთეული ტესტები ამოწმებენ ცალკეულ ერთეულებს იზოლაციაში (დამოკიდებულებების მოჩვენებით), ეს იზოლაცია ნიშნავს, რომ ისინი **ვერ ამოწმებენ რეალურ ინტეგრაციას**: ერთეული შეიძლება ჩააბარდეს მის ყველა ტესტს მაგრამ ზე წაიშალდეს როდესაც სინამდვილეში გაერთიანდება სხვებთან (არასწორი ვარაუდების გამო დამოკიდებულების შესახებ, რეალური მონაცემთა ბაზის ქვერი იყო არასწორი, API კონტრაქტის შეუსაბამობა, ან კონფიგურაციის პრობლემები). **ინტეგრაციული ტესტები** ავსებენ ამ ხარვეზს ტესტირებით **კომპონენტების მუშაობის რეალური (ან რეალისტური) დამოკიდებულებებით** — ამოწმებენ, რომ კოდი ნამდვილად მუშაობს რეალური მონაცემთა ბაზით, რომ სერვისები სწორად ურთიერთქმედებენ, და რომ ინტეგრაციის წერტილები ფუნქციონირებენ — იჭერენ მავთულვის, მონაცემთა-ფენის და კონტრაქტის ხარვეზებს, რომელთა გამო იზოლირებული ერთეული ტესტები აკლდებათ.

ამ კომპლემენტარული ურთიერთობის გაგება (ერთეული ტესტები იზოლირებული ლოგიკისთვის, ინტეგრაციული ტესტები რეალური ურთიერთქმედებებისთვის) ამ მნიშვნელოვანი ოდნობა რომ არცერთი მარტივი არ არის.

განხილვების გაგება — რომ ინტეგრაციული ტესტები უფრო ნელია (რეალური I/O და სამეწამე, ამიტომ ისინი პირამიდის შუა ნაწილში იყრებიან ერთეული ტესტებზე ნაკლებებით), იყენებენ ტესტის მონაცემთა ბაზები/გარემოს, ფოკუსირებენ მნიშვნელოვან ინტეგრაციის წერტილებზე (მონაცემთა წვდომა, მნიშვნელოვანი სერვის ურთიერთქმედებები, API), და მოითხოვს ფრთხილ ტესტის მონაცემთა/მდგომარეობის მართვას — ასახავს პრაქტიკულ ინტეგრაციული ტესტირებას.

ინტეგრაციული ტესტები უზრუნველყოფს დაკრებილი ნაწილების მუშაობის დამაჯერებელს, რომელიც ერთეული ტესტებმა მარტივი ვერ მისცემთ.

მას შემდეგ რაც რეალური აპლიკაციები ურთიერთქმედი კომპონენტებისგან შედგება და ინტეგრაციის ხარვეზები (მონაცემთა ბაზის პრობლემები, კონტრაქტის შეუსაბამობა, კონფიგურაციის შეცდომები) ჩვეულებრივი და აკლდება ერთეული ტესტებს, და რადგან ინტეგრაციული ტესტირება იჭერს მათ კომპონენტების ერთად მუშაობის ამოწმებით, ინტეგრაციული ტესტირების გაგება ღირებული, პრაქტიკულად-რელევანტური ცოდნა — ერთეული ტესტირების აუცილებელი დანამატი, რომელიც იჭერს ურთიერთქმედების ხარვეზებს, მნიშვნელოვანი ყოვლისმომცველი ტესტირებისთვის, რომელიც გადამოწმებს არა მხოლოდ იზოლირებულ ერთეულებს, არამედ რომ სისტემის ნაწილები რეალურად სწორად მუშაობენ ერთად.