పరీక్షలో assertions అంటే ఏమిటి?

Question

Accepted Answer

**Assertions** అనేవి ఒక పరీక్షలో ఉండే స్టేట్‌మెంట్‌లు, అవి **ఒక షరతు నిజమైనదైనా లేదా కాదా అని చెక్ చేస్తాయి** — వాస్తవ ఫలితం ఆశించిన ఫలితం ఎలా ఏకీభవిస్తుందో సరిచేసుకుంటాయి. పరీక్షలు pass లేదా fail అని నిర్ణయించేందుకు అవి ప్రధానమైనవి: ఒక assertion విఫలమైతే, పరీక్ష విఫలమవుతుంది.

## Assertions ఏమి చేస్తాయి

```text
An ASSERTION checks that something is as expected:
  → "assert that the actual value EQUALS the expected value"
  → if TRUE → the assertion passes; if FALSE → the assertion FAILS → the TEST FAILS
→ Assertions are how a test VERIFIES behavior (the "check" part of a test).
```

## సాధారణ assertion రకాలు

```js
// equality
expect(result).toBe(5);                  // strict equality
expect(obj).toEqual({ name: 'Ann' });    // deep/value equality (objects)

// truthiness / null
expect(value).toBeTruthy();
expect(value).toBeNull();
expect(value).toBeDefined();

// comparisons
expect(count).toBeGreaterThan(0);
expect(price).toBeLessThanOrEqual(100);

// collections / strings
expect(array).toContain('item');
expect(array).toHaveLength(3);
expect(text).toMatch(/pattern/);          // regex

// errors
expect(() => risky()).toThrow();          // expect a function to throw

// negation
expect(value).not.toBe(null);
```

## మంచి assertions

```text
✓ Assert the SPECIFIC expected outcome (clear what's being checked)
✓ Use the RIGHT matcher (toBe vs toEqual; specific > generic)
✓ Clear FAILURE messages (good assertions/matchers explain what failed)
✓ Don't over-assert (test one behavior) or under-assert (verify the actual result)
```

## ఇది ఎందుకు ముఖ్యమైనది

Assertions అర్థం చేసుకోవడం ప్రాథమికమైనది ఎందుకంటే అవి **పరీక్షలు ప్రవర్తనను సరిచేసుకోసే ప్రధాన యంత్రావళి** — pass లేదా fail అని నిర్ణయించుకోసే — కనుక ఇది ఎటువంటి పరీక్ష రాయడానికి అপరిహార్యమైన, తప్పక తెలుసుకోవలసిన జ్ఞానం.

ఒక assertion **ఒక షరతు నిజమైనదైనా కాదా అని చెక్ చేస్తుంది** (సాధారణంగా వాస్తవ ఫలితం ఆశించిన ఫలితం ఏకీభవిస్తుందా అని), మరియు ఇది పరీక్షలో "verification" భాగం: ఒక assertion చెక్ కు పాస్ అయితే షరతు సరిపోతుంది, మరియు అది విఫలమైతే పరీక్ష విఫలమవుతుంది.

Assertions లేకుండా, ఒక పరీక్ష ఏదీ సరిచేసుకోవదు — కాబట్టి అర్థం చేసుకోవడం అర్థవంతమైన పరీక్షలు రాయడానికి ప్రాథమికమైనది.

**సాధారణ assertion రకాలను** అర్థం చేసుకోవడం — సమానత (strict `toBe` వర్సెస్ objects కోసం deep/value `toEqual`, ఒక ముఖ్యమైన తేడా), truthiness మరియు null checks, comparisons, collection మరియు string checks, error assertions (ఒక ఫంక్షన throw చేస్తుందా అని verify చేయడం), మరియు negation — ఏ పరీక్ష సరిచేసుకోవాలో ప్రకటించడానికి అవసరమైన ఆచరణాత్మక జ్ఞానం.

**మంచి assertion అభ్యాసాలను** అర్థం చేసుకోవడం — నిర్దిష్ట ఆశించిన ఫలితం assert చేయడం (ఏ ఫలితం చెక్ చేస్తారో స్పష్టంగా), సరైన matcher ఉపయోగించడం (ఉదా. object comparison కోసం `toEqual`, `toBe` కాదు), clear failure messages నిశ్చయం చేయడం (కాబట్టి విఫలమైన పరీక్ష ఏమి తప్పిందో వివరిస్తుంది), మరియు assertions సమతుల్యం చేయడం (ఒక ప్రవర్తన పరీక్ష, కానీ వాస్తవ ఫలితం verify చేయడం) — clear, effective పరీక్షలు రాయడాన్ని ప్రతిబింబిస్తుంది.

Assertions అనేవి ప్రతిটి పరీక్ష ప్రవర్తనను ఎలా సరిచేసుకుంటాయో (ఒక పరీక్షను అర్థవంతమైనదిగా చేసే ప్రాథమిక చెక్) మరియు అర్థం చేసుకోవడం అవి — రకాలు, సరైన matchers, మరియు మంచి అభ్యాసాలు — ఎటువంటి పరీక్ష రాయడానికి అవసరమైనది, అందువల్ల assertions అర్థం చేసుకోవడం ఎటువంటి పరీక్ష సరిచేసుకోవాలో express చేయడానికి మరియు verify చేయడానికి అవసరమైన, ప్రాథమిక పరీక్ష జ్ఞానం — పరీక్షల ప్రధాన బిల్డింగ్ బ్లాక్, సరిక్రమంగా చేక్‌చేయడానికి ఆశించిన ప్రవర్తన express చేయడానికి మరియు verify చేయడానికి అవసరమైనది, మరియు అర్థవంతంగా దోషాలు సరిచేసుకోవే పరీక్షలు రాయడానికి ప్రాథమికమైనది, ఎవరైనా పరీక్షలు రాయడానికి ఒక ప్రాథమిక yog్యత.