რა არის მოკები, სტაბები და ტესტის დაბალი?

Question

Accepted Answer

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

## ტესტის ორმაგი რატომ საჭირო

```text
To test a unit in ISOLATION, replace its real dependencies (DB, API, services) with
TEST DOUBLES (fake stand-ins):
  → isolate the unit (test ONLY it, not its dependencies)
  → FAST (no real DB/network); CONTROLLED (set up exact scenarios, including errors);
    DETERMINISTIC (no external flakiness)
```

## ტესტის ორმაგის ტიპები

```text
STUB → provides canned RESPONSES to calls (returns preset data):
  → "when getUser is called, return this fake user" — controls inputs to the unit
MOCK → a stub that also VERIFIES interactions (was it called? how? with what?):
  → "verify save() was called once with these arguments" — checks behavior/interactions
SPY → wraps a real (or fake) object and RECORDS calls (verify how it was used)
FAKE → a working but simplified implementation (e.g. an in-memory database)
DUMMY → a placeholder passed but not actually used
```

```js
// stub: control what a dependency returns
const userService = { getUser: jest.fn().mockReturnValue({ name: 'Ann' }) };
// mock verification: check an interaction happened
expect(emailService.send).toHaveBeenCalledWith('ann@x.com');
```

## მოკი სტაბის წინააღმდეგ (მთავარი განსხვავება)

```text
STUB → controls INPUTS (provides data the unit needs) — "state" verification
MOCK → verifies OUTPUTS/interactions (was the dependency called correctly?) — "behavior"
  verification
→ Use stubs to provide data; mocks to verify the unit called a dependency correctly.
⚠️ Over-mocking → tests coupled to implementation (brittle); mock at the right boundaries.
```

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

ტესტის ორმაგების (მოკები, სტაბები და ა.შ.) გაგება მნიშვნელოვანია, რადგან ისინი **აუცილებელია იზოლირებული ერთეულის ტესტების დასაწერად**, ამიტომ ეს ღირებული, ხშირად გამოყენებული ტესტირების ცოდნაა.

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

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

მოკი-სტაბ განსხვავების გაგება — **სტაბები კონტროლირებენ შეყვანას** (დათვლის შემოწმება: მონაცემების მიწოდება), **მოკები კი ამოწმებენ გამოსავალს/ინტერაქციებს** (ქცევის შემოწმება: შემოწმება, რომ ერთეულმა სწორად მოიკიდა დამოკიდებულებები) — მნიშვნელოვანია ცნებითი ცოდნა, რომელიც ხშირად აურთავთ, და თითოეულის სათანადოდ გამოყენება მნიშვნელოვანია.

ზედმეტი მოკირების აბუჩი (გამომეტი მოკირება უკავშირებს ტესტებს განხორციელების დეტალებს, რაც მათ დამანგრეველს ხდის, ამიტომ უნდა მოკირება სწორი საზღვრებით) ასახავს ზრდასრული ტესტირების მსჯელობას.

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

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