ஒரு AI உதவியாளரை பயன்படுத்தி ஒரு বিদ்யமான செயல்பாட்டிற்கான அலகு சோதனைகளை எழுதுவது எப்படி?

Question

IT Interview Practice · Accepted Answer

சரியாகப் பயன்படுத்தினால், AI சோதனையின் **கணக்கெடுப்பு** பகுதிতে சிறந்தது — இது விளிம்பு வழக்குகளை சிந்திக்கிறது மற்றும் வேகமாக நிலையான குறியீட்டை எழுதுகிறது. ஆனால் நீங்கள் **உறுதிப்படுத்தல்கள் அর்থপூર்ணவை என்பதை சரிபார்க்க வேண்டும்**, কারணNone AI எதையும் நிரூபிக்காமல் சோதனைகளை எழுத மகிழ்ச்சியாக இருக்கும்.

## பணிப்பாய்வு

1. **செயல்பாடு மற்றும் அதன் ஒப்பந்தத்தை கொடுக்கவும்** — இது என்ன செய்ய வேண்டும், உள்ளீடு/வெளியீட்டு வகைகள் மற்றும் தவறான உள்ளீட்டை எவ்வாறு சামாளிக்க வேண்டும். சோதனைகள் நீங்கள் விவரிக்கும் விவரக்குறிப்பை விட சிறந்ததாக இருக்க முடியாது.
2. **விளிம்பு வழக்குகளுக்கு வெளிப்படையாக கேட்கவும்** — எல்லைகள் (0, வெற்று, அதிகபட்சம்) மற்றும் பிழை பாதைகள் (null, எதிர்மறை, தவறான வகை), சந்தோஷமான பாதை மட்டுமல்ல.
3. **உறுதிப்படுத்தல்கள் அர்த்தபூர்ணவை என்பதை சரிபார்க்கவும்** — குறியீட்டின் தற்போதைய நடத்தையைக் உறுதிப்படுத்தும் சோதனை (பிழைத்தாலும்) பயனற்றது. ஒவ்வொரு உறுதிப்படுத்தலும் *நோக்கம்* ஒப்பந்தத்தை குறியாக்கத்தை சரிபார்க்கவும்.

## உதாரணம்

```js
// Function under test, with its contract:
// applyDiscount(price, percent) -> price reduced by percent.
// Contract: percent must be 0..100; throws RangeError otherwise. price >= 0.
function applyDiscount(price, percent) {
  if (percent < 0 || percent > 100) throw new RangeError('percent out of range');
  return price - (price * percent) / 100;
}
```

```js
// AI-suggested test cases (Jest) — note the edge and error paths, not just happy path:
test('applies a normal discount', () => {
  expect(applyDiscount(100, 20)).toBe(80);       // happy path
});
test('0% leaves price unchanged', () => {
  expect(applyDiscount(100, 0)).toBe(100);       // boundary: lower edge
});
test('100% makes it free', () => {
  expect(applyDiscount(100, 100)).toBe(0);       // boundary: upper edge
});
test('rejects percent above 100', () => {
  expect(() => applyDiscount(100, 150)).toThrow(RangeError); // error path
});
```

AI விளிம்பு வழக்குகளை (0 மற்றும் 100) மற்றும் நீங்கள் மறக்கக்கூடிய பிழை பாதையை பரிந்துரைத்தது. `toBe(80)` *சரியான* எதிர்பார்க்கப்பட்ட மதிப்பு என்பதை உறுதிப்படுத்தும் வேலை உங்களுடையது, செயல்பாடு சிறிய வெளியீட்டைக் கொடுப்பது மட்டுமல்ல.

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

சோதனையின் கடினமான பகுதி `test(...)` தொகுதிகளை தட்டுவது அல்ல — இது **நீங்கள் வேறுவிதமாக মிス செய்யும் வழக்குகளைப் பற்றி சிந்திப்பது**, மற்றும் AI இந்த அகலத்தில் உண்மையிலேயே சிறந்தது. ஆனால் நீங்கள் சொல்லாவிட்டால், உங்கள் குறியீடு *என்ன* செய்ய வேண்டும் என்பதற்கு அது எந்த ধারணাவும் இல்லை, எனவே பிரதிபலিதமாக **சோதனைகளை எழுதுவதற்கு பல** (அவை சந்தோஷம் கொள்ளும், ஆனால் செயல்பாடு தவறாக இருந்தாலும் சந்தோஷம் கொள்ளும்). AI ஐ விளிம்பு வழக்கு ஜெனারேட்டராகக் கருதி நீங்கள் உறுதிப்படுத்தல்களை சொந்தமாக வைத்திருந்தால், நீங்கள் பரந்த கவரேஜ் மற்றும் உண்மையான சரியான தன்மை பெறுவீர்கள் — AI இலிருந்து வேகம், உங்களிலிருந்து판断.

பணிப்பாய்வு

உதாரணம்

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

தொடர்புடைய கேள்விகள்