ടെസ്റ്റ് ജനറേഷനായി AI: എവിടെ സഹായിക്കുന്നു, എവിടെ വഞ്ചിക്കുന്നു

AI വേഗത്തിൽ ടെസ്റ്റുകൾ എഴുതുന്നു. എന്നാൽ യഥാർത്ഥമെന്ന് തോന്നിക്കുന്നതും എന്നാൽ തെറ്റായ കാര്യങ്ങൾ പരിശോധിക്കുന്നതുമായ ടെസ്റ്റുകളും ഇത് എഴുതുന്നുണ്ടാകാം. നിങ്ങളുടെ കോഡ് കവറേജ് (coverage) കൂടുന്നത് കാണപ്പെട്ടേക്കാം, പക്ഷേ നിങ്ങളുടെ കോഡ് ഇപ്പോഴും തകരാറിലായിരിക്കും.

ചില പ്രത്യേക ജോലികൾക്കായി AI മികച്ചതാണ്. ഇവയ്ക്കായി ഇത് ഉപയോഗിക്കാം:

• ഒരു നല്ല ഉദാഹരണത്തിൽ നിന്ന് കൂടുതൽ കാര്യങ്ങൾ കണ്ടെത്താൻ (Extrapolate). നിങ്ങൾ ഒരു മികച്ച ടെസ്റ്റ് എഴുതിയാൽ, അതേ ശൈലിയിൽ പത്ത് ടെസ്റ്റുകൾ കൂടി AI-ക്ക് എഴുതാൻ കഴിയും.
• ആവർത്തന സ്വഭാവമുള്ള ടൈപ്പിംഗ് ജോലികൾക്കായി. setup blocks, teardown, factory helpers എന്നിവയ്ക്കായി ഇത് ഉപയോഗിക്കാം.
• പ്രാരംഭ ഘടന (initial scaffolding) തയ്യാറാക്കാൻ. ഒരു ശൂന്യമായ ഫയലിനേക്കാൾ വേഗത്തിൽ ഇത് നിങ്ങളെ എഡിറ്ററിലേക്ക് എത്തിക്കും.

"കോൺട്രാക്റ്റ്" (contract) തീരുമാനിക്കാൻ നിങ്ങൾ AI-യെ അനുവദിക്കുമ്പോഴാണ് അപകടം തുടങ്ങുന്നത്.

നിങ്ങൾ ഒരു ഫംഗ്ഷൻ നൽകി ടെസ്റ്റുകൾ ആവശ്യപ്പെട്ടാൽ, AI നിലവിലെ കോഡ് വായിക്കുകയും കോഡ് ഇപ്പോൾ എന്ത് ചെയ്യുന്നുവോ അത് പരിശോധിക്കുകയും ചെയ്യുന്നു. കോഡ് എന്ത് ചെയ്യണം എന്നല്ല അത് പരിശോധിക്കുന്നത്. ഇത് ഒരു 'ക്ലോസ്ഡ് ലൂപ്പ്' (closed loop) സൃഷ്ടിക്കുന്നു. AI ഒരു അനുമാനം നടത്തുന്നു, കോഡ് എഴുതുന്നു, തുടർന്ന് അതേ അനുമാനത്തോട് യോജിക്കുന്ന ടെസ്റ്റുകൾ എഴുതുന്നു.

പ്രൊഡക്ഷനിൽ ബഗുകൾ (bugs) ഉണ്ടാകുമ്പോൾ, അത് സംഭവിക്കുന്നത് ടെസ്റ്റ് സ്യൂട്ട് ബഗിന്റെ പക്ഷത്തായതുകൊണ്ടാണ്.

ഈ മൂന്ന് കെണികളെ സൂക്ഷിക്കുക:

1. ഇംപ്ലിമെന്റേഷൻ അടിസ്ഥാനമാക്കിയുള്ള ടെസ്റ്റുകൾ (Implementation-shaped tests) ബിസിനസ് റൂളുകൾക്ക് പകരം AI പലപ്പോഴും ലോജിക് പാത്തുകളാണ് (logic paths) പരിശോധിക്കുന്നത്. നിങ്ങൾ ഒരു ചെറിയ ആന്തരിക മാറ്റം വരുത്തിയാൽ പോലും, ഫലം ശരിയാണെങ്കിൽ പോലും ടെസ്റ്റുകൾ പരാജയപ്പെടും. ഇത് റീഫാക്റ്ററിംഗിനെ (refactoring) ഒരു പേടിസ്വപ്നമാക്കുന്നു.

2. ഉപരിപ്ലവമായ എഡ്ജ് കേസുകൾ (Shallow edge cases) nulls, empty strings, പൂജ്യങ്ങൾ എന്നിവ പരിശോധിക്കാൻ AI മിടുക്കനാണ്. ഇവ വളരെ വ്യക്തമായ കാര്യങ്ങളാണ്. എന്നാൽ "ഡൊമെയ്ൻ എഡ്ജുകൾ" (domain edges) കണ്ടെത്താൻ അതിന് കഴിയില്ല. നിങ്ങളുടെ പ്രത്യേക ടൈംസോൺ ബഗുകളോ, ഡാറ്റാബേസ് വ്യതിയാനങ്ങളോ, അല്ലെങ്കിൽ നിങ്ങളുടെ സവിശേഷമായ ബിസിനസ് റൂളുകളോ അതിന് അറിയില്ല.

3. ബ്രൈറ്റിൽ മോക്കുകൾ (Brittle mocks) എല്ലാം മോക്ക് (mock) ചെയ്യാൻ AI ഇഷ്ടപ്പെടുന്നു. ഇത് രണ്ട് പ്രശ്നങ്ങളിലേക്ക് നയിക്കുന്നു:

• മോക്ക് തെറ്റാണ്. യാഥാർത്ഥ്യവുമായി പൊരുത്തപ്പെടാത്ത ഒരു വ്യാജ API പതിപ്പിനെയാണ് ഇത് അനുകരിക്കുന്നത്.
• മോക്ക് ഇംപ്ലിമെന്റേഷനെ തളച്ചിടുന്നു. ഫൈനൽ ഔട്ട്‌കമിന് പകരം നിങ്ങളുടെ കോഡ് മറ്റ് ഫംഗ്ഷനുകളെ എങ്ങനെ വിളിക്കുന്നു എന്നാണ് ഇത് പരിശോധിക്കുന്നത്.

AI എങ്ങനെ ശരിയായി ഉപയോഗിക്കാം:

"ഉദ്ദേശ്യം" (intent) AI-യുടെ പരിധിയിൽ നിന്ന് മാറ്റി നിർത്തുക.

• ആദ്യം കോൺട്രാക്റ്റ് എഴുതുക. ഓരോ ടെസ്റ്റിനും ലളിതമായ ഇംഗ്ലീഷിൽ ഒരു വാചകം എഴുതുക. ഉദാഹരണത്തിന്: "Expired codes must return the original amount."
• ആ വാചകങ്ങൾ AI-ക്ക് നൽകുക. അസെർഷനുകൾ (assertions) എഴുതാൻ അതിനെ അനുവദിക്കുക, എന്നാൽ അതിന്റെ അർത്ഥം നിങ്ങൾ നൽകണം.
• അതിരുകളിൽ മാത്രം മോക്ക് ചെയ്യുക (Mock at the boundaries). ബാഹ്യമായ API-കളോ ഡാറ്റാബേസുകളോ മാത്രം മോക്ക് ചെയ്യുക. നിങ്ങളുടെ സ്വന്തം ഇന്റേണൽ മോഡ്യൂളുകളുടെ യഥാർത്ഥ പതിപ്പുകൾ ഉപയോഗിക്കുക.
• ഒരു ഡൊമെയ്ൻ എഡ്ജ് കേസ് നേരിട്ട് എഴുതുക. ഓരോ തവണയും ഒരു ഫംഗ്ഷൻ പൂർത്തിയാക്കുമ്പോൾ, നിങ്ങളെ ഭയപ്പെടുത്തുന്ന ഒരു കാര്യം എഴുതി വെക്കുക. അതിനെ AI-യ്ക്കുള്ള പ്രോംപ്റ്റ് ആയി ഉപയോഗിക്കുക.

AI ഒരു ഉൽപ്പാദനക്ഷമതാ ഉപകരണം (productivity tool) മാത്രമാണ്, ചിന്തയ്ക്ക് പകരമല്ല. ടെസ്റ്റിന്റെ ബോഡി എഴുതാൻ അത് ഉപയോഗിക്കുക, എന്നാൽ ടെസ്റ്റ് എന്തിനുവേണ്ടിയാണെന്ന് തീരുമാനിക്കാൻ ഒരിക്കലും അതിനെ അനുവദിക്കരുത്.

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