તમારું AI એવા ટેસ્ટ લખે છે જે ક્યારેય નિષ્ફળ જઈ શકતા નથી
તમે AI પાસે ટેસ્ટ માંગો છો. તે તમને બાર ગ્રીન ટેસ્ટ આપે છે. તમારું CI પાસ થાય છે. તમે કોડ મર્જ કરો છો. ત્રણ દિવસ પછી, એક બગ પ્રોડક્શનમાં પહોંચી જાય છે. તમે ટેસ્ટ જુઓ છો. તેઓ પાસ થયા હતા, પરંતુ તેઓ કંઈ પણ ટેસ્ટ કરી શક્યા નહોતા.
ગ્રીન ટેસ્ટ એ કોઈ પુરાવો નથી. તે માત્ર એક પરિકલ્પના (hypothesis) છે. AI એવી પરિકલ્પનાઓ લખે છે જે ક્યારેય નિષ્ફળ જતી નથી.
આ ફંક્શન જુઓ:
func Discount(total int) int {
if total > 100 {
return total - 10
}
return total
}
AI કદાચ આ રીતે ટેસ્ટ લખી શકે છે:
func TestDiscount(t *testing.T) {
got := Discount(150)
if got < 0 {
t.Errorf("result should not be negative")
}
}
આ ટેસ્ટ ગ્રીન છે. તે કોડ રન કરે છે, તેથી તમારું કવરેજ સારું દેખાય છે. પરંતુ આ ટેસ્ટ ફક્ત એટલું જ તપાસે છે કે પરિણામ શૂન્યથી ઓછું છે કે નહીં. જો તમે ડિસ્કાઉન્ટમાં કોઈ ગાણિતિક ભૂલ કરો, તો પણ ટેસ્ટ ગ્રીન જ રહેશે. તે વર્તણૂક (behavior) તપાસતું નથી. તે ફક્ત એટલું જ તપાસે છે કે સિસ્ટમ ચાલુ છે કે નહીં.
આ એક જાળ છે. કવરેજ એ લાઈનો ગણે છે જેને તમે સ્પર્શ કરો છો. તે મહત્વના એસર્શન્સ (assertions) ને ગણતું નથી. 90% કવરેજ રિપોર્ટ ખરાબ કોડને છુપાવી શકે છે.
AI ને ગ્રીન લાઈટ મેળવવાનો સૌથી ટૂંકો રસ્તો જોઈએ છે. તે નબળા એસર્શન્સ અને એવા મોક્સ (mocks) પસંદ કરે છે જે કંઈ પણ ટેસ્ટ કરતા નથી.
આને સુધારવા માટે, એક નિયમ અપનાવો: તપાસો કે ટેસ્ટને ખબર છે કે નિષ્ફળ કેવી રીતે થવું.
જાણીજોઈને તમારા કોડમાં ફેરફાર કરો. જો ટેસ્ટ ગ્રીન જ રહે છે, તો તે ટેસ્ટ નકામો છે. તેને ફેંકી દો.
અસલી ટેસ્ટ આવો દેખાય છે:
func TestDiscount(t *testing.T) {
if got := Discount(150); got != 140 {
t.Errorf("Discount(150) = %d, want 140", got)
}
}
જો તમે લોજિક બગાડો છો, તો આ ટેસ્ટ તરત જ 'રેડ' (નિષ્ફળ) થઈ જશે. તે અસરકારક છે.
તમે દરેક ટેસ્ટ માટે આ જાતે કરી શકતા નથી. તેના બદલે મ્યુટેશન ટેસ્ટિંગ (mutation testing) નો ઉપયોગ કરો. Go માં Gremlins જેવા ટૂલ્સ તમારા કોડમાં નાના ફેરફારો કરે છે. તેઓ તપાસે છે કે તમારા ટેસ્ટ આ ફેરફારો પકડી શકે છે કે નહીં.
જો કોઈ ફેરફાર ટેસ્ટને નિષ્ફળ ન બનાવે, તો તમારા ટેસ્ટ સ્યુટમાં ખામી છે.
હું AI કોડ માટે આનો ઉપયોગ કરું છું. હું AI ને તેનું કામ પૂરું થયું છે તેમ જાહેર કરવા દેતો નથી. હું એક ગેટ (gate) રાખું છું. ટૂલ કોડમાં ફેરફાર (mutate) કરે છે. જો ટેસ્ટ ગ્રીન જ રહે છે, તો AI એ તેને ફરીથી લખવું પડશે. ટેસ્ટ સારો છે કે નહીં તેનો નિર્ણય AI નથી લેતું, પણ મ્યુટેશન લે છે.
કોઈ પણ AI ટેસ્ટ મારા કોડબેઝમાં ત્યારે જ પ્રવેશ કરે છે જ્યારે તે સાબિત કરે કે તે નિષ્ફળ જઈ શકે છે. જે ટેસ્ટ નિષ્ફળ જઈ શકતો નથી તે ટેસ્ટ ન હોવા કરતાં પણ વધુ ખરાબ છે. ટેસ્ટનો અભાવ સ્પષ્ટ હોય છે, પરંતુ નકલી ટેસ્ટ જોખમી હોય છે.
ગ્રીન લાઈટ પર વિશ્વાસ કરવાનું બંધ કરો. ટેસ્ટની કિંમત એટલી જ છે જેટલો તે 'રેડ' બતાવી શકે છે.
Source: https://dev.to/ohugonnot/your-ai-writes-tests-that-can-never-fail-3i57
Optional learning community: https://t.me/GyaanSetuAi