மாக்குகள், ஸ்டப்புகள் மற்றும் டெஸ்ட் டபுள்ஸ் என்றால் என்ன?

Question

Accepted Answer

**Test doubles** என்பவை பரীक்ষைகளில் உண்மையான சார்புகளுக்கு பதிலாக நிற்கும் பொருட்கள் — **mocks**, **stubs**, **spies**, **fakes**, மற்றும் **dummies** உட்பட. இவை பரீக்ষணையின் கீழ் உள்ள குறியீட்டை அதன் சார்புகளிலிருந்து (தரவுத்தளங்கள், APIs, சேவைகள்) தனிமைப்படுத்துகின்றன, இதனால் வேகமான, கவனம் செலுத்திய, கட்டுப்படுத்தப்பட்ட அலகு பரீக்ষைகள் சாத்தியமாகின்றன.

## Test doubles ஏன் பயன்படுத்தப்படுகின்றன

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

## Test doubles இன் வகைகள்

```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');
```

## Mock vs stub (முக்கிய வேறுபாடு)

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

## இது ஏன் முக்கியமானது

Test doubles (mocks, stubs, முதலியவை) புரிந்துகொள்வது முக்கியமானது, ஏனெனில் அவை **தனிமைப்படுத்தப்பட்ட அலகு பரீக்ষைகளை எழுதுவதற்கு அপরிহார்யமாக** உள்ளன, இதனால் இது மূল்யமான, அடிக்கடி பயன்படுத்தப்படும் பரீக்ষண அறிவாகும்.

এक அலகை தனிமைப்படுத்தி பரீक்ষிக்க வேண்டுமெனில் (அலகு பரீக்ষணையின் இலக்கு), நீங்கள் அதன் உண்மையான சார்புகளை (தரவுத்தளங்கள், APIs, சேவைகள்) **test doubles** உடன் மாற்ற வேண்டும் — இதனால் **வேகமான** பரீக்ষைகள் (உண்மையான I/O இல்லாமல்), **கட்டுப்படுத்தப்பட்ட** (சரியான பரিস்திதிகளை அமைக்கும் உண்மையான சார்புகளுடன் தூண்ட கடினமான பிழை நிலைமைகள் உட்பட), மற்றும் **நிர்ধारணீயமான** (வெளிப்புற தொய்வு இல்லாமல்) பரீக்ষைகள் உதவுகின்றன.

**வகைகள்** மற்றும் அவற்றின் நோக்கங்களைப் புரிந்துகொள்வது அவசியம்: **stubs** (சார்புகள் என்ன திரும்ப வேண்டும் என்பதைக் கட்டுப்படுத்த பாதுகாக்கப்பட்ட பதிலிகளை வழங்குதல் — அலகுக்கு குறிப்பிட்ட தரவு வழங்குதல்), **mocks** (stubs இன் மேலும் இடைவினைகளைச் சரிபார்க்குதல் — அலகு சரியாக சார்பை அழைத்ததை சரிபார்ப்பது), **spies** (உண்மையான அல்லது போலி பொருட்களில் அழைப்புகளை பதிவுசெய்தல்), **fakes** (கூட-நினைவு தரவுத்தளங்கள் போன்ற செயல்படும் எளிமைப்படுத்தப்பட்ட செயல்படுத்தல்கள்), மற்றும் **dummies** (இடம்பிடிப்புகள்).

**முக்கிய mock-vs-stub வேறுபாடு** — stubs உள்ளீடுகளைக் கட்டுப்படுத்துகின்றன (நிலை சரிபார்ப்பு: தரவு வழங்குதல்) என்றால் mocks வெளியீடுகள்/இடைவினைகளைச் சரிபார்க்குகின்றன (நடத்தை சரிபார்ப்பு: அலகு சரியாக சார்புகளை அழைத்ததை சரிபார்ப்பது) — புரிந்துகொள்வது முக்கியமான கருத்தியல் அறிவாகும், இது அடிக்கடி குழப்பிக்கப்படுகிறது, மற்றும் ஒவ்வொன்றையும் சரியாகப் பயன்படுத்துவது முக்கியமாகும்.

**over-mocking இன் ஆபத்து** (அதிக mocking பரீக்ষைகளை செயல்படுத்தল விவரங்களுக்கு இணைத்துவிடுகிறது, அவற்றை உடையக்கூடியதாக்குகிறது, எனவே சரியான எல்லைகளில் mock செய்ய வேண்டும்) — பெள்ளிய பரீக்ষண판断 பிரதிபலிக்கிறது.

Test doubles அலகு பரீக்ষணைகளில் குறியீட்டை தனிமைப்படுத்த தொடர்ந்து பயன்படுத்தப்படுகின்றன.

தனிமைப்படுத்தப்பட்ட அலகு பரீக்ষணைக்கு உண்மையான சார்புகளை test doubles உடன் மாற்றுவதற்கு (வேகத்திற்கு, கட்டுப்பாட்டிற்கு, மற்றும் நிர்ধரணீயதைக்கு) தேவையாகும், மற்றும் வகைகள், mock-vs-stub வேறுபாடு, மற்றும் over-mocking இன் ஆபத்து புரிந்துகொள்வது நல்ல தனிமைப்படுத்தப்பட்ட பரீக்ષைகளை எழுத வேண்டியது இருப்பதால், test doubles புரிந்துகொள்வது மூல்யமான, அடிக்கடி பயன்படுத்தப்படும் பரீக்ષண அறிவாகும் — அலகு பரீக்ষணைக்கு அপரிহார்யம், குறியீட்டைத் தனிமைப்படுத்த தொடர்ந்து பயன்படுத்தப்படுகிறது, மற்றும் கவனம் செலுத்திய, கட்டுப்படுத்தப்பட்ட பரீக்ষைகளை எழுதுவதற்கு மற்றும் over-mocking இன் உடையக்கூடிய தன்மை தவிர்ப்பதற்கு முக்கியமாகும், কার்যকর அலகு பரீக்ষணைக்கான ஒரு மূல்য வBiology.