નફો:
- પરીક્ષણ પિરામિડ અને કવર મર્યાદા અને ભૂલની પરિસ્થિતિઓ તેમજ સુખી દૃશ્યો અનુસાર કૃત્રિમ બુદ્ધિ સાથે યુનિટ, એકીકરણ અને UI પરીક્ષણો ઉત્પન્ન કરવાની ક્ષમતા
- ખાલી/નકામું પરીક્ષણો અને ફૂલેલા કવરેજને નીંદણ કરવાની ક્ષમતા એ ચકાસીને કે જનરેટ થયેલ દરેક પરીક્ષણ ખરેખર વર્તનને માન્ય કરે છે.
- પરીક્ષણ ભૂલ પકડે છે તેની ખાતરી કરવી અને કોડે શું કરવું જોઈએ તે AI ને કહીને તેને બગ ઠીક કરવાથી અટકાવે છે
કોડ લખવું એ અડધું કામ છે; કોડ યોગ્ય રીતે કામ કરે છે તે સાબિત કરવું એ બીજો અડધો ભાગ છે. મોબાઇલ એપ્લિકેશન્સ સેંકડો વિવિધ ઉપકરણો, સ્ક્રીન કદ, ઓપરેટિંગ સિસ્ટમ સંસ્કરણો અને વપરાશકર્તા વર્તણૂકોનો સામનો કરે છે. આ બધાનું જાતે પરીક્ષણ કરવું અશક્ય છે; એટલા માટે સ્વયંસંચાલિત પરીક્ષણ (કોડ પરીક્ષણ કોડ — પરીક્ષણ જે માનવ ક્લિક વિના ચાલે છે) એ મોબાઇલ ગુણવત્તાની કરોડરજ્જુ છે. AI પરીક્ષણો લખવામાં અદ્ભુત રીતે કાર્યક્ષમ છે કારણ કે પરીક્ષણો લખવા એ તેને ગમે તે પ્રકારનું પેટર્ન વર્ક છે: ચોક્કસ ઇનપુટ્સ માટે ચોક્કસ વર્તનને માન્ય કરવું. આ એકમમાં, અમે એઆઈ સાથે યુનિટ ટેસ્ટિંગ, ઈન્ટરફેસ ટેસ્ટિંગ અને ઓટોમેશનને કેવી રીતે ઝડપી બનાવવું તે શીખીશું, પરંતુ માનવ આંખો દ્વારા પરીક્ષણની ગુણવત્તાની ખાતરી કરીશું.
પરીક્ષણ પિરામિડ: શું પરીક્ષણ કરવું અને કેટલું
તંદુરસ્ત પરીક્ષણ વ્યૂહરચના પિરામિડ જેવું લાગે છે. આધારમાં મોટી સંખ્યામાં એકમ પરીક્ષણોનો સમાવેશ થાય છે (ઝડપી પરીક્ષણ જે એકલ કાર્ય અથવા વર્ગને અલગતામાં પરીક્ષણ કરે છે); તેઓ ઝડપી અને સસ્તા છે. મધ્યમાં ઓછું એકીકરણ પરીક્ષણ છે (બહુવિધ ભાગો એકસાથે કેવી રીતે કાર્ય કરે છે તેનું પરીક્ષણ). ટોચ પર ન્યૂનતમ UI/એન્ડ-ટુ-એન્ડ પરીક્ષણ છે (વપરાશકર્તાની જેમ સ્ક્રીન પર ક્લિક કરીને પરીક્ષણ કરવામાં આવે છે); તેઓ વાસ્તવિક છે પરંતુ ધીમા અને નાજુક છે. AI દરેક સ્તર પર મદદ કરે છે, પરંતુ સૌથી વધુ મૂલ્ય પાયા પર છે: બિઝનેસ લોજિકના એકમ પરીક્ષણો ઝડપથી ઉત્પન્ન કરે છે.
ટેસ્ટ પ્રકાર
અવકાશ
ઝડપ
AI કાર્યક્ષમતા
એકમ પરીક્ષણ
સિંગલ ફંક્શન/વર્ગ
ખૂબ જ ઝડપી
ખૂબ ઊંચા
એકીકરણ
આંતરસ્તર
મધ્યમ
ઉચ્ચ
UI / એન્ડ-ટુ-એન્ડ
બધી સ્ક્રીન સ્ટ્રીમ
ધીમું
મધ્યમ (નાજુક)
ટીપ: જ્યારે AI ને "આ કાર્ય માટે પરીક્ષણો જનરેટ કરવા" કહે છે, ત્યારે સ્પષ્ટપણે ધારના કિસ્સાઓ માટે પૂછો: ખાલી ઇનપુટ, નલ, નકારાત્મક સંખ્યા, ખૂબ મોટી કિંમત, નેટવર્ક ભૂલ. AI સરળતાથી સુખી માર્ગ ઉત્પન્ન કરે છે; વાસ્તવિક ભૂલો સરહદોમાં છુપાઈ જાય છે અને જો તમને તે ત્યાં ન જોઈતી હોય તો બહાર કૂદી પડે છે.
AI સાથે પરીક્ષણો લખવાના પગલાં
- ચકાસવા માટેના વર્તનને વ્યાખ્યાયિત કરો. "આ ફંક્શન આ ઇનપુટને આ આઉટપુટ આપવો જોઈએ."
- ફ્રેમવર્ક સ્પષ્ટ કરો. Android પર JUnit + MockK, iOS પર XCTest, Espresso (Android) અથવા UI માટે XCUITest (iOS).
- મર્યાદા રાજ્યો માટે પૂછો. ખુશ દૃશ્ય + ભૂલ + બ્રેકપોઇન્ટ્સ.
- મૉક ઑબ્જેક્ટ્સનું સંચાલન કરો. નેટવર્ક અને ડેટાબેઝ જેવી બાહ્ય અવલંબનને પરીક્ષણ માટે અનુકરણ કરવામાં આવે છે (વાસ્તવિક સેવાને બદલે મોક — નિયંત્રિત મોક).
- પરીક્ષણ ચલાવો અને ચકાસો. શું પરીક્ષણ પાસ થાય છે, શું તે ખરેખર અર્થપૂર્ણ કંઈપણની પુષ્ટિ કરે છે?
પાંચમું પગલું નિર્ણાયક છે. AI કેટલીકવાર નકામી પરીક્ષણો ઉત્પન્ન કરે છે જે "હંમેશા પાસ થાય છે"; ઉદાહરણ તરીકે, એક પરીક્ષણ જે કંઈપણ ચકાસતું નથી અથવા તેના પોતાના નકલી ડેટાને તપાસે છે. પાસ થનાર કસોટી અને મૂલ્યવાન કસોટી એ અલગ વસ્તુઓ છે.
સાવધાન: માત્ર એઆઈ ઉત્પન્ન કરી શકે છે તેનો અર્થ એ નથી કે ટેસ્ટ સાચો છે. કેટલીકવાર AI કોડના વર્તમાન (કદાચ ખામીયુક્ત) વર્તનને "સાચો" તરીકે સ્વીકારે છે અને તે મુજબ પરીક્ષણો લખે છે. આવા પરીક્ષણ બગને પકડવાને બદલે તેને ઠીક કરે છે. તમે નક્કી કરો કે પરીક્ષણ શું અપેક્ષા રાખે છે; એઆઈને કહો કે તેણે શું કરવું જોઈએ, કોડ શું કરે છે તે નહીં.
પરીક્ષણ કવરેજ માપ અને ભ્રમણા
ટેસ્ટ કવરેજ (કોડની કેટલી ટકાવારી પરીક્ષણો દ્વારા ચલાવવામાં આવે છે) એ ઉપયોગી પરંતુ ભ્રામક મેટ્રિક છે. 90% કવરેજ સૂચવે છે કે 90% કોડનો અમલ કરવામાં આવ્યો છે; પરંતુ તે ચકાસવામાં આવ્યું નથી કે તે રેખાઓ યોગ્ય રીતે કામ કરી રહી છે. એક પરીક્ષણ જે લાઇન ચલાવે છે અને પરિણામ તપાસતું નથી તે અવકાશને વધારે છે પરંતુ સુરક્ષા પ્રદાન કરતું નથી. ધ્યેય ઉચ્ચ સંખ્યાઓ નથી, પરંતુ અર્થપૂર્ણ માન્યતા છે. તમે AI સાથે ઝડપથી સ્કેલ કરી શકો છો, પરંતુ ખાતરી કરો કે દરેક પરીક્ષણ ખરેખર વર્તનનું પરીક્ષણ કરે છે.
ત્રણ નાના કેસો
કેસ 1 - સરહદની સ્થિતિ પકડાઈ. AI ને બેંકિંગ એપ્લિકેશનમાં મની ટ્રાન્સફર કાર્ય માટે પરીક્ષણો માટે કહેવામાં આવ્યું હતું, અને ખાસ કરીને "નકારાત્મક રકમ" અને "બેલેન્સ કરતાં વધુ" દૃશ્યો ઉમેરવામાં આવ્યા હતા. પરીક્ષણમાં જાણવા મળ્યું કે ટ્રાન્સફર નકારાત્મક રકમ સાથે અવરોધિત કરવામાં આવ્યું ન હતું; ઉત્પાદનમાં આ એક મોટી સુરક્ષા નબળાઈ હશે. એક લીટી નિયંત્રણ ઉમેરીને બંધ. પાઠ: સીમા પરીક્ષણો સૌથી મૂલ્યવાન પરીક્ષણો છે.
કેસ 2 - નકલી પરીક્ષણ. એક ટીમને AI દ્વારા ઉત્પાદિત 40 યુનિટ પરીક્ષણો સાથે કવરેજ 85% સુધી વધારવામાં રાહત મળી હતી. નિરીક્ષણ દરમિયાન, એવું જોવામાં આવ્યું હતું કે મોટાભાગના પરીક્ષણોએ ખરેખર કોઈ આઉટપુટની ચકાસણી કરી નથી, તેઓએ ફંક્શનને કૉલ કર્યો અને assertTrue(true) લખ્યું. કવરેજ વધારે હતું પરંતુ રક્ષણ શૂન્ય હતું. પરીક્ષણો ફરીથી ગોઠવવામાં આવી હતી અને વાસ્તવિક માન્યતાઓ સાથે ફરીથી લખવામાં આવી હતી. પાઠ: કવરેજ નંબરો જૂઠું બોલી શકે છે.
કેસ 3 — UI પરીક્ષણ ઝડપી. એક ઈ-કોમર્સ ટીમે 20 મિનિટમાં AI સાથે એડ-ટુ-કાર્ટ ફ્લોની XCUITest સ્ક્રિપ્ટ લખી હતી; જો તે હાથથી લખવામાં આવે, તો તે અડધો દિવસ લેશે. AI અનુમાનિત સ્ક્રીન તત્વ ઓળખકર્તાઓ; ટીમે તેમને વાસ્તવિક કોડ સાથે મેચ કર્યા અને તેમને ઠીક કર્યા. ડ્રાફ્ટ ઝડપ વાસ્તવિક છે, પરંતુ ઓળખકર્તાની ચકાસણી એ માનવ કાર્ય છે.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા પ્રોમ્પ્ટ: "આ કાર્ય માટે એક પરીક્ષણ લખો."
પાવરફુલ પ્રોમ્પ્ટ: "JUnit5 + MockK સાથે આ કોટલિન ફંક્શન માટે એકમ પરીક્ષણો તૈયાર કરો. કાર્ય: નાણાં ટ્રાન્સફર (રકમ, સ્ત્રોત, લક્ષ્ય). પરીક્ષણ કરવા માટેની વર્તણૂકો (કોડ શું કરવું જોઈએ):- માન્ય ટ્રાન્સફર સફળ હોવી જોઈએ- નકારાત્મક અથવા શૂન્ય રકમ નકારવી જોઈએ- સંતુલન કરતાં વધુ રકમ નકારવી જોઈએ, માત્ર એક જ વસ્તુનું પરીક્ષણ કરવું આવશ્યક છે, જેનું નામ યોગ્ય છે. વર્ણનાત્મક હોવું જોઈએ, બાહ્ય સેવાની મજાક ઉડાવો, ખાલી નિવેદન લખશો નહીં."
નકલ કરી શકાય તેવા નમૂનાઓ
યુનિટ ટેસ્ટ ટેમ્પલેટ: "[ભાષા] માટે આ ફંક્શન માટે [JUnit/XCTest] યુનિટ ટેસ્ટ જનરેટ કરો. અપેક્ષિત વર્તણૂક: [શું કરવું]. શામેલ કરો: ખુશ દૃશ્ય, નલ ઇનપુટ, બ્રેકપોઇન્ટ્સ, એરર કેસ. દરેક ટેસ્ટને એક જ વર્તન ચકાસવા દો; અર્થપૂર્ણ નિવેદનનો ઉપયોગ કરો; મોક. [કોડ]"
UI પરીક્ષણ નમૂનો: "[Espresso/XCUITest] સાથે નીચેના પ્રવાહનું UI પરીક્ષણ લખો: [વપરાશકર્તા પ્રવાહ પગલું દ્વારા]. ઍક્સેસિબિલિટી id સાથે સ્ક્રીન ઘટકો પસંદ કરો, ટેક્સ્ટને બદલે idનો ઉપયોગ કરો. રાહ વ્યૂહરચના ઉમેરો. એલિમેન્ટ id ને વાસ્તવિક કોડ સાથે મેચ કરવાનું યાદ કરાવો."
ટેસ્ટ ઓડિટ ટેમ્પલેટ:"આ પરીક્ષણોની તપાસ કરો:1) શું તેઓ ખરેખર આઉટપુટ/વર્તણૂકને ચકાસે છે અથવા તે શૂન્ય છે? 2) શું તેઓ મર્યાદાના કેસોને આવરી લે છે? 3) શું તેઓ બગને ઠીક કરે છે અથવા યોગ્ય વર્તનની અપેક્ષા રાખે છે? નબળા પરીક્ષણોને ફ્લેગ કરો અને મજબૂત કરો. [પરીક્ષણો]"
કવરેજ ઓપ્ટિમાઇઝેશન ટેમ્પલેટ: "આ વર્ગના વણચકાસાયેલ ભાગોને ઓળખો અને અર્થપૂર્ણ પરીક્ષણો સૂચવો. વાસ્તવિક જોખમ સાથેના પાથને પ્રાધાન્ય આપો, માત્ર કવરેજની સંખ્યાને નહીં. [કોડ]"
સામાન્ય ભૂલો
- માત્ર ખુશ દૃશ્ય પરીક્ષણ. ભૂલો મર્યાદાની સ્થિતિમાં સંગ્રહિત થાય છે; તેમના માટે ખુલ્લેઆમ પૂછો.
- ખાલી/નકામું પરીક્ષણ સ્વીકારવું. assertTrue(true) પ્રકારના પરીક્ષણો અવકાશને વધારે છે અને કોઈ રક્ષણ પૂરું પાડતું નથી.
- AI પાસે કોડ શું કરી રહ્યો છે તેની ચકાસણી કરે છે. પરીક્ષણમાં કોડે શું કરવું જોઈએ તેની અપેક્ષા રાખવી જોઈએ; અન્યથા તે બગને સુધારે છે.
- હેતુ માટે અવકાશ નંબરની ભૂલ કરવી. 90% કવરેજનો અર્થ 90% ચોકસાઈ નથી.
- UI પરીક્ષણમાં ટેક્સ્ટ સાથે લિંક કરવું. જ્યારે ટેક્સ્ટ બદલાય છે ત્યારે પરીક્ષણ તૂટી જાય છે; સ્થિર ઓળખકર્તા (id) નો ઉપયોગ કરો.
- ખોટી રીતે મોક્સ સેટ કરી રહ્યા છીએ. "યુનિટ ટેસ્ટ" જે વાસ્તવિક સેવાને કૉલ કરે છે તે ધીમી અને બરડ હશે.
સારાંશમાં
પરીક્ષણ એ મોબાઇલ ગુણવત્તાની કરોડરજ્જુ છે, અને AI આ ક્ષેત્રમાં ખૂબ જ કાર્યક્ષમ છે, ખાસ કરીને એકમ પરીક્ષણમાં. પરીક્ષણ પિરામિડને અનુસરો: ઘણા એકમો, મધ્યમ એકીકરણ, થોડું UI પરીક્ષણ. AI ને ખુશ દૃશ્ય તેમજ મર્યાદિત કેસ અને ભૂલ પાથ માટે સ્પષ્ટપણે પૂછો. ખાતરી કરો કે જનરેટ થયેલ દરેક પરીક્ષણ ખરેખર વર્તનને માન્ય કરે છે; ખાલી પરીક્ષણો અને ફૂલેલું કવરેજ ભ્રામક છે. સૌથી અગત્યનું, એઆઈને કહો કે કોડે શું કરવું જોઈએ, નહીં કે તે શું કરે છે, તેથી પરીક્ષણ બગને પકડે છે, તેને ઠીક કરતું નથી.
એપ્લિકેશન કાર્ય
બિઝનેસ લોજિક ફંક્શન (દા.ત. ડિસ્કાઉન્ટ કેલ્ક્યુલેશન અથવા ફોર્મ વેલિડેશન) માટે "યુનિટ ટેસ્ટ ટેમ્પલેટ" નો ઉપયોગ કરીને AI તરફથી પરીક્ષણોની વિનંતી કરો અને સ્પષ્ટપણે મર્યાદા કેસો (નલ, નકારાત્મક, ખૂબ મોટા) નો ઉલ્લેખ કરો. જનરેટ કરેલ પરીક્ષણો ચલાવો, પછી "ટેસ્ટ ઓડિટ ટેમ્પલેટ" સાથે સમાન પરીક્ષણોનું ઓડિટ કરાવો. ઓછામાં ઓછું એક નબળું પરીક્ષણ શોધો, તેને મજબૂત કરો અને પરીક્ષણો કાર્યની વાસ્તવિક ભૂલને પકડે છે કે કેમ તેની તપાસ કરો (નાની ભૂલ ઉમેરીને).
ચેકલિસ્ટ
- [ ] મેં ટેસ્ટ પિરામિડ (પ્રાધાન્યતા એકમ) માટે યોગ્ય સ્તર પસંદ કર્યું
- [ ] હું ખુશ દૃશ્ય ઉપરાંત મર્યાદા અને ભૂલના કેસ ઇચ્છતો હતો
- [ ] મેં ચકાસ્યું છે કે દરેક પરીક્ષણમાં અર્થપૂર્ણ નિવેદન છે
- [ ] મેં AI ને કહ્યું કે કોડે શું કરવું જોઈએ, નહીં કે તે શું કરે છે
- [ ] મેં વાસ્તવિક જોખમના માર્ગો પર ધ્યાન કેન્દ્રિત કર્યું, કવરેજની સંખ્યા પર નહીં
- [ ] મેં UI પરીક્ષણોમાં સ્થિર ઓળખકર્તાનો ઉપયોગ કર્યો, હું ટેક્સ્ટ સાથે બંધાયેલો નથી