మీ 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")
    }
}

ఈ టెస్ట్ గ్రీన్ (green) గా ఉంటుంది. ఇది కోడ్‌ను రన్ చేస్తుంది, కాబట్టి మీ కవరేజ్ (coverage) బాగున్నట్లు కనిపిస్తుంది. కానీ ఈ టెస్ట్ కేవలం ఫలితం సున్నా కంటే తక్కువ ఉందో లేదో మాత్రమే తనిఖీ చేస్తుంది. మీరు డిస్కౌంట్‌ను గణిత లోపం (math error) గా మార్చినా, టెస్ట్ గ్రీన్ గానే ఉంటుంది. ఇది ప్రవర్తనను (behavior) తనిఖీ చేయదు. ఇది కేవలం లైట్లు వెలుగుతున్నాయో లేదో మాత్రమే చూస్తుంది.

ఇది ఒక ఉచ్చు. కవరేజ్ అనేది మీరు తాకిన లైన్లను మాత్రమే లెక్కిస్తుంది. ఇది ముఖ్యమైన అసర్షన్స్ (assertions) ను లెక్కించదు. 90% కవరేజ్ రిపోర్ట్ కూడా పాడైపోయిన కోడ్‌ను దాచిపెట్టవచ్చు.

AI గ్రీన్ లైట్ కోసం అతి తక్కువ మార్గాన్ని కోరుకుంటుంది. అది దేనినీ టెస్ట్ చేయని సాఫ్ట్ అసర్షన్స్ (soft assertions) మరియు మోక్స్ (mocks) ను ఎంచుకుంటుంది.

దీనిని సరిదిద్దడానికి, ఒక నియమాన్ని పాటించండి: ఒక టెస్ట్ ఎలా విఫలం కావాలో దానికి తెలుసో లేదో తనిఖీ చేయండి.

కావాలనే మీ కోడ్‌ను మార్చండి. ఒకవేళ టెస్ట్ గ్రీన్ గానే ఉంటే, ఆ టెస్ట్ పనికిరాదు. దానిని పారేయండి.

నిజమైన టెస్ట్ ఇలా ఉంటుంది:

func TestDiscount(t *testing.T) {
    if got := Discount(150); got != 140 {
        t.Errorf("Discount(150) = %d, want 140", got)
    }
}

మీరు లాజిక్‌ను విచ్ఛిన్నం చేస్తే, ఈ టెస్ట్ వెంటనే రెడ్ (red) అవుతుంది. ఇది లోపాన్ని పట్టుకుంటుంది.

ప్రతి టెస్ట్‌కు మీరు ఇలా మాన్యువల్‌గా చేయలేరు. దానికి బదులుగా మ్యుటేషన్ టెస్టింగ్ (mutation testing) ఉపయోగించండి. Go లో Gremlins వంటి టూల్స్ మీ కోడ్‌కు చిన్న చిన్న మార్పులను చేస్తాయి. మీ టెస్ట్‌లు ఆ మార్పులను గుర్తిస్తున్నాయో లేదో అవి తనిఖీ చేస్తాయి.

ఒక మార్పు వల్ల టెస్ట్ విఫలం కాకపోతే, మీ టెస్ట్ సూట్‌లో లోపం ఉన్నట్లు అర్థం.

నేను AI కోడ్ కోసం దీనిని ఉపయోగిస్తాను. AI తన పని పూర్తయిందని ప్రకటించనివ్వను. నేను ఒక గేట్ (gate) రన్ చేస్తాను. ఆ టూల్ కోడ్‌ను మ్యుటేట్ (mutate) చేస్తుంది. ఒకవేళ టెస్ట్ గ్రీన్ గానే ఉంటే, AI దానిని మళ్ళీ రాయాలి. ఒక టెస్ట్ మంచిదా కాదా అనేది AI నిర్ణయించదు. మ్యుటేషన్ నిర్ణయిస్తుంది.

విఫలం కావగలదని నిరూపించకుండా ఏ AI టెస్ట్ కూడా నా కోడ్‌బేస్‌లోకి ప్రవేశించదు. విఫలం కాలేని టెస్ట్, అసలు టెస్ట్ లేకపోవడం కంటే దారుణమైనది. టెస్ట్ లేకపోవడం స్పష్టంగా తెలుస్తుంది. కానీ నకిలీ టెస్ట్ ప్రమాదకరం.

గ్రీన్ లైట్లను నమ్మడం ఆపండి. ఒక టెస్ట్ ఎంత రెడ్ (red) ని ఉత్పత్తి చేయగలదో, అంతవరకు దాని విలువ ఉంటుంది.

Source: https://dev.to/ohugonnot/your-ai-writes-tests-that-can-never-fail-3i57

Optional learning community: https://t.me/GyaanSetuAi