યુનિટ ટેસ્ટ જનરેશન અને ટેસ્ટેબિલિટી: AI સાથે મજબૂત પરીક્ષણ

નફો:

• કૃત્રિમ બુદ્ધિમત્તાને સ્વીકૃતિના નિયમથી સ્વતંત્ર રીતે એકમ પરીક્ષણોમાં અપેક્ષિત મૂલ્યની ગણતરી કરીને ભૂલભરેલા વર્તનને 'સાચા' તરીકે સ્વીકારવાથી અટકાવવાની ક્ષમતા
• AAA અને FIRST સિદ્ધાંતો લાગુ કરીને અને બાહ્ય નિર્ભરતાની મજાક ઉડાવીને ઝડપી, સ્વતંત્ર અને પુનરાવર્તિત પરીક્ષણો છાપવાની ક્ષમતા
• પરિવર્તન (કોડ બ્રેકિંગ) સાથે પરીક્ષણો ચકાસવાની ક્ષમતા અને ડિઝાઈનની ગંધ તરીકે ટેસ્ટ-ટુ-ટેસ્ટ કોડને ઓળખવાની ક્ષમતા

પરીક્ષણ પિરામિડનું સૌથી મોટું અને ઝડપી સ્તર એકમ પરીક્ષણ છે - પરીક્ષણ જે કોઈપણ કાર્ય અથવા કોડના નાના ટુકડાને અન્ય દરેક વસ્તુથી અલગ કરીને ચકાસે છે. હજારો યુનિટ ટેસ્ટ સેકન્ડોમાં ચાલે છે અને જ્યારે કોડ હજુ પણ ડેવલપરની સ્ક્રીન પર હોય ત્યારે બગ પકડે છે. આર્ટિફિશિયલ ઇન્ટેલિજન્સ (AI) કદાચ એકમ પરીક્ષણો બનાવવામાં સૌથી વધુ નિપુણ છે: તમે તેને એક કાર્ય આપો છો, AI ડઝનેક પરીક્ષણો ઉત્પન્ન કરે છે. પરંતુ આ ખૂબ જ સગવડતા સૌથી મોટા ટ્રેપને જન્મ આપે છે: AI સરળતાથી એવા પરીક્ષણો ઉત્પન્ન કરે છે જે "લીલા ચમકતા હોય છે પરંતુ કંઈપણ ચકાસતા નથી" અથવા કોડના વર્તમાન (કદાચ ખામીયુક્ત) વર્તનને "સાચા" તરીકે સ્વીકારે છે. આ એકમમાં તમે શીખી શકશો કે AI સાથે ખરેખર રક્ષણાત્મક એકમ પરીક્ષણો કેવી રીતે લખવા અને ટેસ્ટેબલ કોડ અને AI વચ્ચેનો સંબંધ.

સારી એકમ કસોટીના ગુણો: પ્રથમ

સારા એકમ પરીક્ષણો પ્રથમ સિદ્ધાંતોને અનુસરે છે: ઝડપી, સ્વતંત્ર (પરીક્ષણો એકબીજા પર નિર્ભર ન હોવા જોઈએ), પુનરાવર્તિત (પુનરાવર્તિત — કોઈપણ વાતાવરણમાં સમાન પરિણામ), સ્વ-માન્યતા (સ્પષ્ટ પાસ/નિષ્ફળ), સમયસર (સમયસર). જ્યારે AI ઉત્પાદન પરીક્ષણો કરાવતી હોય ત્યારે આ સિદ્ધાંતો યાદ કરાવો; ખાસ કરીને પૂછો કે પરીક્ષણ "સ્વતંત્ર" અને "પુનરાવર્તિત" થવા માટે બહારની દુનિયા (વાસ્તવિક ડેટાબેઝ, નેટવર્ક, ઘડિયાળ) પર આધારિત નથી.

AAA પેટર્ન અને અભિવ્યક્ત ભાર

નક્કર એકમ કસોટી એએએ સ્ટ્રક્ચરને અનુસરે છે: ગોઠવો (તૈયાર કરો — ઇનપુટ્સ અને નિર્ભરતાઓ સેટ કરો), એક્ટ (એક્ઝિક્યુટ કરો — ટેસ્ટ હેઠળ ફંક્શનને કૉલ કરો), એસર્ટ (માન્ય કરો — અપેક્ષિત મૂલ્ય સાથે પરિણામની તુલના કરો). નિર્ણાયક એક ભારપૂર્વક છે. સૌથી સામાન્ય ભૂલ એઆઈ કરે છે તે પરીક્ષણ હેઠળના કોડના આઉટપુટમાંથી દાવો મેળવવામાં આવે છે - "કોડ જે કંઈ પણ આપે છે તે સાચું છે" તર્ક. આ પરીક્ષણને અર્થહીન બનાવે છે. અપેક્ષિત મૂલ્યને સ્વતંત્ર રીતે નિર્ધારિત કરવાનો સાચો માર્ગ છે (સ્વીકૃતિ માપદંડમાંથી, તેની જાતે ગણતરી કરો).

ધ્યાન આપો: જો તમે AI ને કહો કે "આ ફંક્શન માટે ટેસ્ટ લખો", તો AI ફંક્શન ચલાવી શકે છે અને તેનું આઉટપુટ "અપેક્ષિત" તરીકે લખી શકે છે. જો ફંક્શન ખોટું હોય તો પણ આ ટેસ્ટ પાસ થાય છે. તેના બદલે, કહો કે "તમે આ નિયમો અનુસાર અપેક્ષિત પરિણામોની ગણતરી કરો છો, કાર્યના વર્તમાન આઉટપુટનો સંદર્ભ આપશો નહીં."

મોક્સ, સ્ટબ અને અવલંબન

એકમ પરીક્ષણ માટે અલગતા જરૂરી છે. જો તમારું કાર્ય ડેટાબેઝ અથવા API પર આધાર રાખે છે, તો તેઓ પરીક્ષણમાં મોક ઑબ્જેક્ટ્સ (મોક/સ્ટબ — એક નિયંત્રિત, વાસ્તવિક નિર્ભરતા માટે ડમી વિકલ્પ) સાથે બદલવામાં આવે છે. આ પરીક્ષણને ઝડપી, સ્વતંત્ર અને પુનઃઉત્પાદનક્ષમ બનાવે છે. AI મોક ઇન્સ્ટોલેશનનું ઉત્પાદન કરી શકે છે; પરંતુ અતિશય ઉપહાસથી સાવધ રહો: ​​જો તમે દરેક વસ્તુની મજાક કરો છો, તો પરીક્ષણ ફક્ત "મૌક શું વળતર આપે છે" ચકાસશે, વાસ્તવિક તર્ક નહીં. સંતુલન: બહારની દુનિયાનું અનુકરણ કરો, પરીક્ષણ હેઠળ વાસ્તવિક તર્કનો અમલ કરો.

પરીક્ષણક્ષમતા અને AI

એક રસપ્રદ પ્રતિસાદ છે: કોડ કે જેનું પરીક્ષણ કરવું મુશ્કેલ છે તે ઘણીવાર ખરાબ રીતે ડિઝાઇન કરાયેલ કોડ હોય છે. જો AI ને ફંક્શન (ઘણી બધી અવલંબન, છુપાયેલ વૈશ્વિક સ્થિતિ, આડ અસરો) માટે પરીક્ષણો લખવામાં મુશ્કેલી હોય, તો તે ડિઝાઇનની ગંધ છે. AI ને પૂછવાથી "તમે આ કોડને પરીક્ષણયોગ્ય બનાવવા માટે કેવી રીતે રિફેક્ટ કરશો" તે બહેતર પરીક્ષણ અને બહેતર કોડ બંને તરફ દોરી જાય છે.

પરિમાણિત પરીક્ષણો અને ડેટાની વિવિધતા

અલગ-અલગ ઇનપુટ્સ સાથે સમાન નિયમને ચકાસવા માટે દરેક વખતે અલગ કસોટી લખવી કંટાળાજનક અને જાળવવી મુશ્કેલ છે. પેરામીટરાઇઝ્ડ ટેસ્ટિંગ - એક માળખું જે ઇનપુટ્સ અને અપેક્ષિત પરિણામોની સૂચિ પર વારંવાર સમાન પરીક્ષણ તર્ક ચલાવે છે - આ પુનરાવર્તનને દૂર કરે છે: એક ટેસ્ટ બોડી ડઝનેક ઇનપુટ જોડીઓ સાથે ખવડાવવામાં આવે છે. જ્યારે તમે તેને તમારા સ્વીકૃતિ નિયમો આપો છો ત્યારે AI આ ઇનપુટ-અપેક્ષિત પરિણામ કોષ્ટકો બનાવવામાં ખૂબ જ કાર્યક્ષમ છે; ખાસ કરીને, તે વ્યવસ્થિત રીતે મર્યાદા મૂલ્યો અને સમકક્ષતા વર્ગોને ટેબ્યુલેટ કરે છે.

પરંતુ અહીં પણ એક છટકું છે: AI પરીક્ષણ હેઠળના કોડમાંથી જનરેટ કરેલ કોષ્ટકમાં અપેક્ષિત પરિણામો મેળવવાનું વલણ ધરાવે છે. પેરામીટરાઇઝ્ડ ટેસ્ટિંગમાં આ ભૂલ વધુ ખતરનાક છે, કારણ કે એક જ ખોટો તર્ક ડઝનેક લાઇનોને અમાન્ય બનાવે છે. તેથી, હંમેશા અપેક્ષિત પરિણામ કૉલમને સ્વીકૃતિના નિયમ અનુસાર સ્વતંત્ર રીતે ગણવામાં આવે છે અને ઓછામાં ઓછી થોડી પંક્તિઓ મેન્યુઅલી માન્ય કરો. "દરેક પંક્તિ શું રજૂ કરે છે" વર્ણન કૉલમ માટે પણ પૂછો; તેથી જ્યારે પંક્તિ તૂટે છે ત્યારે તમે તરત જ જોઈ શકો છો કે કઈ સ્થિતિ તૂટેલી છે.

ટીપ: પેરામીટરાઈઝ્ડ ટેસ્ટ ટેબલમાં ઈરાદાપૂર્વક "ટ્રેપ પંક્તિ" ઉમેરો — એટલે કે, જાણી જોઈને પરિણામ ખોટું લખો. જો તમે પરીક્ષણ ચલાવો ત્યારે તે લાઇન લાલ ન થાય, તો તમારું પરીક્ષણ ખરેખર તે પરિસ્થિતિને ચકાસતું નથી. આ એક ઝડપી મોક-પાસ ચેક છે.

નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ

નબળા: "આ કાર્ય માટે એકમ પરીક્ષણ લખો."

સશક્ત: "ટેક્સ કેલ્ક્યુલેટ(રકમ, દર) કાર્ય માટે [ભાષા/ફ્રેમવર્ક] એકમ પરીક્ષણો લખો. સ્વીકૃતિ નિયમ: પરિણામ = રકમ * દર, 2 દશાંશ સુધી ગોળાકાર; નકારાત્મક રકમ અથવા દર ભૂલ ફેંકે છે; જો દર 0 હોય તો 0 વળતર આપે છે. AAA માળખુંનો ઉપયોગ કરો. મેન્યુઅલી ગણતરી કરો. અપેક્ષિત નિયમો અનુસાર મેન્યુઅલી ગણતરી કરો. THE વર્તમાન નિયમોના મૂલ્યો સાથે પુનઃપ્રાપ્ત કરશો નહીં. અને નકારાત્મક કિસ્સાઓ (0, નકારાત્મક, ખૂબ મોટા, રાઉન્ડથી દશાંશ સુધી) દરેક પરીક્ષણના નામને તે બાહ્ય નિર્ભરતા "નં."

શક્તિશાળી પ્રોમ્પ્ટ; તે સ્વીકૃતિ નિયમ, સ્વતંત્ર અપેક્ષિત મૂલ્ય અપેક્ષા, માળખું અને ધાર કેસ આપે છે. આમ, કસોટી કોડનો અરીસો નહીં પણ નિયમનો રક્ષક બને છે.

એકમ પરીક્ષણ ગુણવત્તા કોષ્ટક

લક્ષણ

ખરાબ પરીક્ષણ (નકલી-વિશ્વાસ)

સારી કસોટી

ભારપૂર્વક

કંઈ નહીં અથવા "નલ નહીં"

અપેક્ષિત કોંક્રિટ મૂલ્ય

અપેક્ષિત મૂલ્ય સ્ત્રોત

કાર્યનું આઉટપુટ

સ્વીકૃતિ નિયમ / મેન્યુઅલ ગણતરી

વ્યસન

વાસ્તવિક DB/નેટવર્ક/કલાક

મોક/સ્ટબ સાથે ઇન્સ્યુલેટેડ

ધાર કેસ

માત્ર સુખી માર્ગ

મર્યાદા, નકારાત્મક, ભૂલ

જ્યારે તમે કોડ તોડશો

લીલો રહે છે

લાલ થઈ જાય છે

નામ

ટેસ્ટ1, ટેસ્ટ મેથડ

તે જે નિયમની પુષ્ટિ કરે છે તેનું વર્ણન કરે છે

ચાર નકલ કરી શકાય તેવા નમૂનાઓ

1) નિયમ આધારિત એકમ પરીક્ષણ:

તમારી ભૂમિકા: સિનિયર સોફ્ટવેર ટેસ્ટ એન્જિનિયર. [ભાષા/ફ્રેમવર્ક] સાથે નીચેના ફંક્શન પર એક યુનિટ ટેસ્ટ લખો: [સહી]. સ્વીકૃતિ નિયમો: [નિયમો].- AAA માળખું વાપરો.- આ નિયમો અનુસાર અપેક્ષિત મૂલ્યોની જાતે ગણતરી કરો; ફંક્શનના વર્તમાન આઉટપુટનો સંદર્ભ આપશો નહીં. - અલગ પરીક્ષણો સાથે મર્યાદા, નકારાત્મક, ભૂલ અને સુખી માર્ગને આવરી લો. - દરેક પરીક્ષણ નામને તે જે નિયમની ચકાસણી કરે છે તેનું વર્ણન કરવા દો. - બાહ્ય અવલંબનનો ઉપહાસ કરવો; વાસ્તવિક તર્ક કાર્ય કરો.

2) પરિવર્તન પ્રતિકાર નિયંત્રણ:

આ એકમ પરીક્ષણો તપાસો. 5 નાના ફેરફારોની સૂચિ બનાવો જે હું પરીક્ષણ હેઠળ કોડમાં કરી શકું છું (a - a + ની જગ્યાએ, a >= a >ને બદલે, એક બાઉન્ડ્રી શિફ્ટ) અને દરેક માટે મને કહો કે આમાંથી કયા પરીક્ષણો લાલ થશે? જો કોઈ પાછું ન મળે, તો પરીક્ષણ અપૂરતું છે. કોડ + પરીક્ષણો: [પેસ્ટ]

3) પરીક્ષણક્ષમતા સમીક્ષા:

આ કાર્ય માટે એકમ કસોટી લખવી શા માટે મુશ્કેલ છે? છુપાયેલ વ્યસન, વૈશ્વિક સ્થિતિ, આડ અસરો, ઘણી બધી જવાબદારીઓ છે? તેને ટેસ્ટેબલ બનાવવા માટે ન્યૂનતમ રિફેક્ટરિંગ સૂચવો; વર્તન બદલશો નહીં. કોડ: [પેસ્ટ કરો]

4) અપૂર્ણ દૃશ્ય પૂર્ણતા:

નીચેના કાર્ય અને ઉપલબ્ધ પરીક્ષણો આપવામાં આવે છે. કયા વર્તન/એજકેસનું ક્યારેય પરીક્ષણ કરવામાં આવ્યું નથી તેની સૂચિ બનાવો (સ્કોપ ગેપ) અને દરેક માટે એક પરીક્ષણ ઉમેરો. કાર્ય + પરીક્ષણો: [પેસ્ટ કરો]

ત્રણ નાના કેસો

કેસ 1 - કોડને પ્રતિબિંબિત કરવાનું પરીક્ષણ કરો. એક વિકાસકર્તા પાસે રાઉન્ડિંગ ફંક્શન માટે AI લખવાનું પરીક્ષણ હતું; 10 પરીક્ષણો લીલા હતા. વાસ્તવમાં, ફંક્શન ખોટી દિશામાં ગોળાકાર થઈ રહ્યું હતું, પરંતુ AI એ ફંક્શનના આઉટપુટમાંથી અપેક્ષિત મૂલ્યો લીધા હતા, તેથી પરીક્ષણોએ ભૂલને "સાચી" ગણી. જ્યારે "નિયમ-સંચાલિત" નમૂના સાથે અપેક્ષિત મૂલ્યોની મેન્યુઅલી ગણતરી કરવામાં આવી, ત્યારે 4 પરીક્ષણો લાલ થઈ ગયા અને વાસ્તવિક ભૂલ જાહેર થઈ.

કેસ 2 - પરિવર્તન નિયંત્રણનું મૂલ્ય. એક ટીમ 45 યુનિટ ટેસ્ટ પર નિર્ભર હતી. "મ્યુટેશન રોબસ્ટનેસ ચેક" સાથે કોડમાં 20 નાના ટ્વીક્સનો પ્રયાસ કર્યો; પરીક્ષણોમાં તેમાંથી માત્ર 11 જ ઝડપાયા. બાકીના 9 અવરોધો શાંતિપૂર્વક પસાર થયા. ટીમ નબળા પરીક્ષણો મજબૂત; આગલા પ્રકાશનમાં આ ઉન્નત પરીક્ષણો દ્વારા વાસ્તવિક ગણતરીની ભૂલ પકડાઈ હતી.

કેસ 3 - અસ્થિરતા એ ડિઝાઇનની ગંધ છે. AI ઓર્ડરિંગ ફંક્શન માટે પરીક્ષણો લખી શક્યું નથી, તેને સતત વાસ્તવિક ડેટાબેઝની જરૂર હતી. "ટેસ્ટિબિલિટી રિવ્યુ" ટેમ્પલેટે દર્શાવ્યું હતું કે ફંક્શન એમ્બેડેડ ડેટાબેઝ એક્સેસ કરે છે. જ્યારે નિર્ભરતા ઇન્જેક્શન દૂર કરવામાં આવ્યું હતું, ત્યારે પરીક્ષણો લખી શકાય છે અને કોડ ક્લીનર બન્યો.

સામાન્ય ભૂલો

• કોડમાંથી અપેક્ષિત મૂલ્ય મેળવવું. AI ફંક્શન આઉટપુટને "સાચો" તરીકે સ્વીકારે છે; પરીક્ષણ કે જે ખામીયુક્ત કોડની પુષ્ટિ કરે છે.
• નિવેદન વિના અથવા તુચ્છ નિવેદન સાથે પરીક્ષણ કરો. "તેણે ભૂલ નથી ફેંકી, તે પાસ થયો" તર્ક; તે કંઈપણ પુષ્ટિ કરતું નથી.
• આત્યંતિક મજાક. દરેક વસ્તુની મજાક ઉડાવવી અને મોક શું આપે છે તે જ પરીક્ષણ; વાસ્તવિક તર્ક ચકાસાયેલ નથી.
• માત્ર સુખી માર્ગ. બાયપાસ મર્યાદા, નકારાત્મક અને ભૂલ સ્થિતિઓ.
• કોડ ભંગ કરીને પરીક્ષણ નથી. પરિવર્તનની તપાસ કર્યા વિના લીલા પર વિશ્વાસ કરવો.
• અસ્થિરતાને અવગણવી. સખત પરીક્ષણને આગળ ધપાવવાને બદલે ખરાબ ડિઝાઇનને ઓળખી અને ઠીક ન કરવી.

સારાંશમાં

એકમ પરીક્ષણો એ પરીક્ષણ પિરામિડનું સૌથી ઝડપી અને સૌથી મોટું સ્તર છે; તે સસ્તી ક્ષણે ભૂલ પકડી લે છે. AI એકમ પરીક્ષણો ઉત્પન્ન કરવામાં ખૂબ જ સક્ષમ છે, પરંતુ તેની સૌથી મોટી મુશ્કેલી એ પરીક્ષણો લખવાની છે જે કોડમાંથી જ અપેક્ષિત મૂલ્ય મેળવીને ખોટી વર્તણૂકને "સાચી" તરીકે ધારે છે. ઉકેલ: સ્વીકૃતિ નિયમો આપો, અપેક્ષિત મૂલ્યોની જાતે ગણતરી કરો, AAA અને FIRST સિદ્ધાંતો લાગુ કરો, બહારની દુનિયાની મજાક કરો અને વાસ્તવિક તર્ક ચલાવો, અને પરિવર્તન (કોડ ભંગ) દ્વારા દરેક પરીક્ષણનું પરીક્ષણ કરો. કોડ કે જેનું પરીક્ષણ કરવું મુશ્કેલ છે તે ડિઝાઇન સાઇન છે જેને ફિક્સિંગની જરૂર છે.

એપ્લિકેશન કાર્ય

તમારા પોતાના પ્રોજેક્ટમાંથી વ્યવસાય નિયમ ધરાવતું ફંક્શન પસંદ કરો. સ્વીકૃતિ નિયમો લખો અને "નિયમ-સંચાલિત એકમ પરીક્ષણ" નમૂના સાથે AI લેખન પરીક્ષણો લો; અપેક્ષિત મૂલ્યોની મેન્યુઅલી ગણતરી કરો. પછી "પરિવર્તન મજબૂતી તપાસ" લાગુ કરો: કોડમાં ઓછામાં ઓછા 5 નાના વિરામ બનાવો અને માપો કે કેટલા પરીક્ષણો લાલ થાય છે. પકડાયેલા ભ્રષ્ટાચાર માટે નવી કસોટી ઉમેરો. કેટલા વિક્ષેપો પકડાયા હતા તેની જાણ કરો (જેમ કે મ્યુટેશન સ્કોર).

ચેકલિસ્ટ

• [ ] મેં સ્વીકૃતિ નિયમો આપ્યા અને અપેક્ષિત મૂલ્યોની જાતે ગણતરી કરી.
• [ ] મેં ખાતરી કરી છે કે પરીક્ષણો કોડમાંથી અપેક્ષિત મૂલ્ય મેળવતા નથી.
• [ ] મેં AAA અને FIRST માર્ગદર્શિકાને અનુસરીને સ્વતંત્ર પરીક્ષણની સ્થાપના કરી છે.
• [ ] મેં બાહ્ય નિર્ભરતાની મજાક ઉડાવી અને વાસ્તવિક તર્ક ચલાવ્યો.
• [ ] મેં મર્યાદા, નેગેટિવ અને એરર કેસો કવર કર્યા છે.
• કોડ (પરિવર્તન) તોડીને મેં સાબિત કર્યું કે પરીક્ષણો ખરેખર રક્ષણ કરે છે.