சோதனை உருவாக்கத்திற்கான AI: அது எங்கு உதவுகிறது மற்றும் எங்கு ஏமாற்றுகிறது
AI சோதனைகளை (tests) வேகமாக எழுதுகிறது. ஆனால், அவை உண்மையானவை போலத் தோன்றினாலும், தவறான விஷயங்களையே சரிபார்க்கும். உங்கள் டெஸ்ட் கவரேஜ் (coverage) அதிகரிப்பதாகத் தெரியலாம், ஆனால் உங்கள் குறியீடு (code) இன்னும் பிழையுடனேயே இருக்கும்.
சில குறிப்பிட்ட பணிகளுக்கு AI சிறந்தது. இதைப் பயன்படுத்தலாம்:
- ஒரு சிறந்த உதாரணத்திலிருந்து விரிவாக்கம் செய்ய. நீங்கள் ஒரு சரியான சோதனையை எழுதினால், AI அதே பாணியில் மேலும் பத்து சோதனைகளை எழுதும்.
- மீண்டும் மீண்டும் செய்யப்படும் தட்டச்சுப் பணிகளைக் கையாள. setup blocks, teardown மற்றும் factory helpers ஆகியவற்றிற்கு இதைப் பயன்படுத்தலாம்.
- ஆரம்பக்கட்ட கட்டமைப்பை (scaffolding) உருவாக்க. ஒரு வெற்று கோப்பை விட, இது உங்களை விரைவாக எடிட்டருக்குக் கொண்டு செல்லும்.
நீங்கள் "ஒப்பந்தத்தை" (contract) தீர்மானிக்க AI-யை அனுமதிக்கும்போது ஆபத்து தொடங்குகிறது.
நீங்கள் ஒரு function-ஐ AI-யிடம் கொடுத்து சோதனைகளைக் கேட்கும்போது, அது குறியீட்டைப் படித்து, அந்த குறியீடு தற்போது என்ன செய்கிறதோ அதையே சோதிக்கும். குறியீடு என்ன செய்ய வேண்டும் என்பதை அது சோதிப்பதில்லை. இது ஒரு மூடிய சுழற்சியை (closed loop) உருவாக்குகிறது. AI ஒரு அனுமானத்தை மேற்கொள்கிறது, குறியீட்டை எழுதுகிறது, பின்னர் அதே அனுமானத்தோடு ஒத்துப்போகும் சோதனைகளை எழுதுகிறது.
பிழைகள் (bugs) தயாரிப்புச் சூழலுக்கு (production) வரும்போது, அவை வருவதற்குக் காரணம், சோதனைத் தொகுப்பு (test suite) அந்தப் பிழைக்கு ஆதரவாகவே இருந்ததுதான்.
இந்த மூன்று பொறிகளிடம் எச்சரிக்கையாக இருங்கள்:
செயல்படுத்தல் சார்ந்த சோதனைகள் (Implementation-shaped tests) AI பெரும்பாலும் வணிக விதிகளைத் (business rules) தவிர்த்துவிட்டு, லாஜிக் பாதைகளை (logic paths) மட்டுமே சோதிக்கிறது. நீங்கள் ஒரு சிறிய உள் விவரத்தை மாற்றினால், முடிவு சரியாக இருந்தாலும் சோதனைகள் தோல்வியடையும். இது refactoring செய்வதை ஒரு দুঃস্বপடாக்கும்.
மேலோட்டமான விளிம்பு நிலைச் சோதனைகள் (Shallow edge cases) nulls, empty strings மற்றும் zeros ஆகியவற்றைச் சோதிப்பதில் AI சிறந்தது. இவை மிக எளிதானவை. ஆனால், "டொமைன் விளிம்புகளை" (domain edges) அதனால் கண்டறிய முடியாது. உங்கள் குறிப்பிட்ட timezone பிழைகள், உங்கள் தரவுத்தளச் சிக்கல்கள் (database quirks) அல்லது உங்கள் தனித்துவமான வணிக விதிகள் பற்றி அதற்குத் தெரியாது.
உடையக்கூடிய மாக்ஸ்கள் (Brittle mocks) AI அனைத்தையும் mock செய்ய விரும்புகிறது. இது இரண்டு சிக்கல்களுக்கு வழிவகுக்கிறது:
- மாக்ஸ் (mock) தவறானது. இது யதார்த்தத்துடன் பொருந்தாத ஒரு போலி API பதிப்பை உருவாக்குகிறது.
- மாக்ஸ் செயல்படுத்தலை முடக்குகிறது (freezes the implementation). இது இறுதி முடிவைச் சோதிப்பதற்குப் பதிலாக, உங்கள் குறியீடு மற்ற function-களை எவ்வாறு அழைக்கிறது என்பதை மட்டுமே சோதிக்கிறது.
AI-யை எவ்வாறு சரியாகப் பயன்படுத்துவது:
"நோக்கத்தை" (intent) AI-யின் எட்டாத தூரத்தில் வைத்திருங்கள்.
- முதலில் ஒப்பந்தத்தை எழுதுங்கள். ஒவ்வொரு சோதனைக்கும் எளிய ஆங்கிலத்தில் ஒரு வாக்கியத்தை எழுதுங்கள். உதாரணம்: "Expired codes must return the original amount."
- அந்த வாக்கியங்களை AI-யிடம் கொடுங்கள். அது assertions-களை எழுதட்டும், ஆனால் அதன் பொருளை நீங்களே வழங்குங்கள்.
- எல்லைகளில் மாக் செய்யுங்கள் (Mock at the boundaries). வெளிப்புற APIs அல்லது தரவுத்தளங்களை (databases) மட்டுமே mock செய்யுங்கள். உங்கள் சொந்த உள் தொகுதிகளின் (internal modules) உண்மையான பதிப்புகளைப் பயன்படுத்துங்கள்.
- ஒரு டொமைன் விளிம்பு நிலைச் சோதனையை (domain edge case) நீங்களே எழுதுங்கள். ஒவ்வொரு முறையும் நீங்கள் ஒரு function-ஐ முடிக்கும்போது, உங்களை அச்சமூட்டும் ஒரு விஷயத்தை எழுதி வையுங்கள். அதை AI-க்கான ஒரு prompt ஆகப் பயன்படுத்துங்கள்.
AI என்பது ஒரு உற்பத்தித் திறன் கருவி (productivity tool), சிந்தனைக்கு மாற்றானது அல்ல. சோதனையின் உடல் பகுதியை (body of the test) எழுத அதைப் பயன்படுத்துங்கள், ஆனால் சோதனை எதற்காக என்பதைத் தீர்மானிக்க அதை ஒருபோதும் அனுமதிக்காதீர்கள்.
Source: https://dev.to/nazar_boyko/ai-for-test-generation-where-it-helps-and-where-it-lies-jhm
Optional learning community: https://t.me/GyaanSetuAi