પરીક্ષણમાં assertions શું છે?

Question

Accepted Answer

**Assertions** એ પરીક્ષણમાંના statements છે જે **તપાસે છે કે શરત સત્ય છે કે નહીં** — ચકાસણી કરે છે કે વાસ્તવિક પરિણામ અપેક્ષિત પરિણામ સાથે મેળ ખાય છે કે નહીં. તેઓ આ છે કે કેવી રીતે પરીક્ષણો પાસ કે નિષ્ફળ તે નક્કી કરે છે તેનો મહત્વપૂર્ણ ભાગ: જો 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 સમજવું મૌલિક છે કારણ કે તેઓ **તે મુખ્ય પદ્ધતિ છે જેના દ્વારા પરીક્ષણો વર્તણૂક ચકાસે છે** — પાસ કે નિષ્ફળ નક્કી કરે છે — તેથી તે આવશ્યક, આવશ્યક જ્ઞાન છે કોઈપણ પરીક્ષણ લખવા માટે.

एक assertion **તપાસે છે કે શરત સત્ય છે** (સામાન્ય રીતે કે વાસ્તવિક પરિણામ અપેક્ષિત પરિણામ સાથે મેળ ખાય છે), અને તે પરીક્ષણનો "ચકાસણી" ભાગ છે: જો assertion પાસ થાય તો તપાસ પકડી રહે છે, અને જો તે નિષ્ફળ થાય તો પરીક્ષણ નિષ્ફળ થાય છે.

Assertions વિના, પરીક્ષણ વાસ્તવમાં કંઈ પણ ચકાસતું નથી — તેથી તેમને સમજવું અર્થપૂર્ણ પરીક્ષણો લખવા માટે મૌલિક છે.

**સામાન્ય assertion પ્રકારોને સમજવું** — સમાનતા (કડક `toBe` વિરુદ્ધ ઊંડી/મૂલ્ય `toEqual` ઑબ્જેક્ટ્સ માટે, એક મહત્વપૂર્ણ તફાવત), સત્યતા અને null તપાસ, સરખામણી, સંગ્રહ અને string તપાસ, error assertions (ચકાસણી કે ફંક્શન એક error ફેંકે છે), અને નકાર — આવશ્યક વ્યવહારિક જ્ઞાન છે જે પરીક્ષણ ચકાસવો જોઈએ તે વ્યક્ત કરવા માટે.

**સારી assertion પ્રથાઓને સમજવું** — ચોક્કસ અપેક્ષિત પરિણામ આરોપણ કરવું (સ્પષ્ટ કે શું તપાસ થાય છે), યોગ્ય matcher વાપરવું (દા.ત. `toEqual` ઑબ્જેક્ટ સરખામણી માટે, `toBe` નહીં), સ્પષ્ટ નિષ્ફળતા સંદેશો સુનિશ્ચિત કરવો (તેથી નિષ્ફળ પરીક્ષણ સમજાવે કે શું ખોટું થયું), અને assertions સંતુલિત કરવું (એક વર્તણૂક પરીક્ષણ કરવું, પરંતુ વાસ્તવિક પરિણામ ચકાસવું) — પસંદગી કરે છે સ્પષ્ટ, અસરકારક પરીક્ષણો લખવું.

Assertions એ છે કે કેવી રીતે દરેક પરીક્ષણ વર્તણૂક ચકાસે છે (મૌલિક તપાસ જે પરીક્ષણને અર્થપૂર્ણ બનાવે છે) અને તેમને સમજવું — પ્રકારો, યોગ્ય matchers, અને સારી પ્રથાઓ — આવશ્યક વ્યવહારિક જ્ઞાન છે કોઈપણ પરીક્ષણ લખવા માટે જે વાસ્તવમાં કંઈ પણ ચકાસે છે, assertions સમજવું આવશ્યક, પાયાનું પરીક્ષણ જ્ઞાન છે — પરીક્ષણોનો મૌલિક બિલ્ડિંગ બ્લોક, અપેક્ષિત વર્તણૂક વ્યક્ત કરવા અને ચકાસવા માટે આવશ્યક, અને તે મોટે ભાગે તપાસે તે પરીક્ષણો લખવા માટે મૌલિક, જે તપાસ કરે છે યોગ્યતા, પરીક્ષણો લખતા કોઈ માટે પણ મૂળભૂત સક્ષમતા.