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

Question

Accepted Answer

**Snapshot testing** என்பது சில output-ஐ (பொதுவாக UI component-இன் rendered output அல்லது data structure) "snapshot" ஆக capture செய்து, future runs-ஐ அதற்கு எதிராக compare செய்கிறது — output மாறும்போது flag செய்கிறது. Unintended changes-ஐ detect செய்ய useful ஆனால் limitations-ஐ புரிந்துகொள்ள வேண்டியுள்ளது.

## Snapshot testing எவ்வாறு செயல்படுகிறது

```text
1. First run → the test RECORDS the output (e.g. a rendered component) as a SNAPSHOT file
2. Later runs → COMPARE the current output to the saved snapshot:
   → MATCHES → pass; DIFFERS → fail (the output changed)
3. If the change is INTENTIONAL → UPDATE the snapshot (review the diff, then accept)
```

```js
// Jest snapshot test (e.g. a React component)
test('renders correctly', () => {
  const tree = render(<Button label="Click" />).toJSON();
  expect(tree).toMatchSnapshot();    // compares to the stored snapshot
});
```

## Uses and benefits

```text
✓ Detect UNINTENDED CHANGES — flags when output changes unexpectedly (UI, serialized data)
✓ FAST to write — no manual assertions for complex output; auto-captures the expected result
✓ Good for UI components (catch unexpected rendering changes), config, large data structures
```

## Limitations (carefully பயன்படுத்தவும்)

```text
⚠️ Snapshots don't verify CORRECTNESS — they capture whatever output exists (even if WRONG);
   they only detect CHANGE, not that the output is RIGHT
⚠️ BLINDLY UPDATING snapshots (jest -u without reviewing) → defeats the purpose (accepting
   broken output) — a common bad habit
⚠️ Large/brittle snapshots → change often, get rubber-stamped, low value
→ Use for change detection; keep snapshots small/focused; REVIEW snapshot diffs;
  don't rely on them alone (combine with real assertions for behavior).
```

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

Snapshot testing-ஐ புரிந்துகொள்வது valuable ஆக இருக்கிறது ஏனெனில் இது **commonly-used technique** ஆக இருக்கிறது (சிறப்பாக UI-க்கு) இது well apply செய்யும்போது useful ஆனால் misuse செய்யும்போது problematic ஆக இருக்கிறது, எனவே அதன் value மற்றும் limitations இரண்டையும் புரிந்துகொள்வது important practical knowledge ஆக இருக்கிறது.

Snapshot testing — output-ஐ capture செய்தல் (பொதுவாக rendered UI component அல்லது data structure) மற்றும் future runs-ஐ stored snapshot-க்கு எதிராக compare செய்தல் — **unintended changes-ஐ detect செய்ய useful ஆக இருக்கிறது**: இது output unexpectedly மாறும்போது flag செய்கிறது (accidental UI rendering changes அல்லது data structure changes-ஐ catch செய்கிறது), **write செய்ய fast ஆக இருக்கிறது** (auto-capturing expected output without manually asserting every detail of complex output), மற்றும் UI components, configuration, மற்றும் large data structures-க்கு suit செய்கிறது.

இந்த benefits-ஐ புரிந்துகொள்வது அதன் popularity-ஐ explain செய்கிறது, சிறப்பாக UI testing-இல்.

ஆனால் **limitations-ஐ புரிந்துகொள்வது critically important** இதை well use செய்ய: snapshots **correctness-ஐ verify செய்யாது** — அவை whatever output exist-ஐ capture செய்கிறது (இது wrong ஆக இருந்தாலும்), only *change* detect செய்கிறது *rightness* அல்ல — எனவே ஒரு snapshot buggy output-ஐ lock in செய்யலாம்.

**Biggest pitfall என்பது blindly updating snapshots** (reviewing the diff இல்லாமல் update command-ஐ run செய்தல்), இது purpose-ஐ defeat செய்கிறது potentially-broken output-ஐ accept செய்வதால் — ஒரு common bad habit.

Large, brittle snapshots that change often rubber-stamped செய்யப்படுகின்றன மற்றும் little value provide செய்கின்றன.

Proper use-ஐ புரிந்துகொள்வது — change detection-க்கு, keeping snapshots small மற்றும் focused, **reviewing snapshot diffs** carefully, மற்றும் அவற்றை alone rely செய்யாமல் (combining with real behavior assertions) — mature judgment-ஐ reflect செய்கிறது இது common misuse-ஐ avoid செய்கிறது.

Snapshot testing widely use செய்யப்படும் (சிறப்பாக UI-க்கு) மற்றும் change detection-க்கு useful ஆனால் easily misuse செய்யப்படும் (lock in wrong output, blindly updating), மற்றும் அதன் value மற்றும் important limitations இரண்டையும் புரிந்துகொள்வது இதை well use செய்ய enable செய்கிறது, மற்றும் snapshot testing widely use செய்யப்படும் (சிறப்பாக UI-க்கு) ஆக இருக்கிறது, snapshot testing-ஐ புரிந்துகொள்வது valuable, practically-relevant knowledge ஆக இருக்கிறது — ஒரு common technique correctly புரிந்துகொள்ள, இங்கே அதன் limitations-ஐ appreciate செய்வது (change detection, correctness அல்ல) மற்றும் proper use (reviewing diffs, blindly updating அல்ல) என்பது technique self-க்கு மணக்கடை important ஆக இருக்கிறது, sound testing judgment reflect செய்கிறது.