AI For Test Generation: எங்கே உதவுகிறது மற்றும் எங்கே ஏமாற்றுகிறது
AI விரைவாக சோதனைகளை (tests) எழுதுகிறது. ஆனால், அவை உண்மையானவை போலத் தோன்றினாலும், தவறான விஷயங்களைச் சரிபார்க்கும் சோதனைகளையும் அது எழுதுகிறது.
நீங்கள் ஒரு function-ஐ AI-இல் பேஸ்ட் செய்கிறீர்கள். முப்பது வினாடிகளுக்குப் பிறகு, உங்களிடம் பன்னிரண்டு வெற்றிகரமான சோதனைகள் உள்ளன. உங்கள் coverage score உயர்கிறது. நீங்கள் அதிக வேலை செய்த உணர்வைப் பெறுகிறீர்கள்.
பிறகு, production-இல் ஒரு bug ஏற்படுகிறது. அந்த பன்னிரண்டு சோதனைகளையும் நீங்கள் பார்க்கும்போது, அவற்றில் எதுவுமே அந்தப் பிழையைக் கண்டறியவில்லை என்பதை உணர்கிறீர்கள்.
உங்கள் code என்ன செய்கிறது என்பதைத்தான் AI சோதித்தது, உங்கள் code என்ன செய்ய வேண்டும் என்பதை அல்ல.
AI பயனுள்ளது, ஆனால் அதை எப்படிப் பயன்படுத்துவது என்பதை நீங்கள் அறிந்திருக்க வேண்டும்.
AI எங்கே வெற்றி பெறுகிறது:
- setup மற்றும் teardown blocks போன்ற boilerplate குறியீடுகளை உருவாக்குதல்.
- மீண்டும் மீண்டும் பயன்படுத்தப்படும் factory helpers மற்றும் data objects-களை எழுதுதல்.
- ஒரு சிறந்த test pattern-இன் பல மாறுபாடுகளை உருவாக்குதல்.
- null, empty strings அல்லது zero போன்ற வெளிப்படையான edge cases-களைக் கையாளுதல்.
AI எங்கே தோல்வியடைகிறது:
- Implementation-அடிப்படையிலான சோதனைகள்: இது business logic-க்குப் பதிலாக code கட்டமைப்பைப் பின்பற்றி சோதனைகளை எழுதுகிறது. நீங்கள் code-ஐ refactor செய்தால், முடிவு சரியாக இருந்தாலும் சோதனைகள் தோல்வியடையும்.
- மேலோட்டமான edge cases: இது வெளிப்படையான பிழைகளைக் கண்டறியும், ஆனால் domain-குறிப்பிட்ட பிழைகளைத் தவறவிடும். உங்கள் timezone சிக்கல்கள், database கட்டுப்பாடுகள் அல்லது உங்கள் குறிப்பிட்ட business விதிகள் பற்றி அதற்குத் தெரியாது.
- உடையக்கூடிய (Brittle) mocks: உண்மையாக இருக்க வேண்டிய உட்புறச் சேவைகளை (internal services) இது mock செய்கிறது. இது சோதனைகளைப் பராமரிப்பதைக் கடினமாக்குகிறது மற்றும் refactor செய்யும் போது எளிதில் உடைந்துவிடும் நிலையை உருவாக்குகிறது.
"test theater"-ஐ உருவாக்காமல் AI-ஐப் பயன்படுத்துவது எப்படி:
- முதலில் contract-ஐ வரையறுக்கவும். சோதனை எதை நிரூபிக்க வேண்டும் என்பதைப் பற்றி ஒரு எளிய ஆங்கில வாக்கியத்தை எழுதவும். உதாரணம்: "An expired code must return the original amount."
- அந்த வாக்கியத்தை AI-இடம் கொடுக்கவும். AI குறியீட்டை எழுதட்டும், ஆனால் அதன் நோக்கம் (intent) உங்களுடையதாக இருக்க வேண்டும்.
- எல்லையில் (boundary) மட்டும் mock செய்யவும். உங்கள் உட்புற மாட்யூல்ஸ்களுக்கு (internal modules) உண்மையான இன்ஸ்டன்ஸ்களைப் (real instances) பயன்படுத்தவும். வெளிப்புற APIs அல்லது databases-களை மட்டும் mock செய்யவும்.
- ஒரு domain edge case-ஐ நீங்களே கைமுறையாக எழுதவும். AI "வெளிப்படையான" விளிம்புகளைக் கையாளும். ஆனால் உண்மையில் production சிக்கல்களை உருவாக்கும் "3 AM" விளிம்புகளை நீங்கள் கையாள வேண்டும்.
சோதனை எதைச் சரிபார்க்கிறது என்பதை AI தீர்மானிக்க விடாதீர்கள். குறியீட்டைத் தட்டச்சு செய்ய அதைப் பயன்படுத்துங்கள், ஆனால் தர்க்கத்தை (logic) நீங்களே வழங்க வேண்டும்.
ஆதாரம்: https://dev.to/nazar_boyko/ai-for-test-generation-where-it-helps-and-where-it-lies-jhm