નફો:
- કૃત્રિમ બુદ્ધિમત્તા સાથે મજબૂત UI ટેસ્ટ કોડ બનાવવાની ક્ષમતા, જેમાં ડેટા-ટેસ્ટિડ, ખુલ્લી રાહ જોવાની અને વાસ્તવિક વપરાશકર્તા પરિણામની ચકાસણી કરે છે
- નાજુક પરીક્ષણો ટાળવાની ક્ષમતા (ખરાબ પસંદગીકાર, અંધ પ્રતીક્ષા) અને પેજ ઑબ્જેક્ટ મોડલ માળખામાં જાળવવા માટે પરીક્ષણોને સરળ બનાવવા
- કોડને તોડીને ઉત્પાદિત દરેક UI પરીક્ષણને ચકાસવાની અને નકલી-પાસ થયેલા પરીક્ષણોને શોધી કાઢવા અને ઠીક કરવાની ક્ષમતા
દરેક ક્લિક, દરેક ફોર્મ ભરો, વપરાશકર્તા બ્રાઉઝરમાં કરે છે તે દરેક પૃષ્ઠ સંક્રમણનું વારંવાર હાથ દ્વારા પરીક્ષણ કરી શકાતું નથી — તેથી જ UI પરીક્ષણ ઓટોમેશન (વપરાશકર્તા ઇન્ટરફેસ; આ પરીક્ષણો વાસ્તવિક બ્રાઉઝરને પ્રોગ્રામેટિક રીતે ચલાવીને વપરાશકર્તાના વર્તનની નકલ કરે છે) અસ્તિત્વમાં છે. સેલેનિયમ, નાટ્યકાર અને સાયપ્રસ આ કામ માટે સૌથી સામાન્ય સાધનો છે. આર્ટિફિશિયલ ઇન્ટેલિજન્સ (AI) આ ટૂલ્સ માટે કોડ લખવામાં અત્યંત કુશળ છે: તમે ટેસ્ટ કેસનું વર્ણન કરો છો, AI તમને કાર્યક્ષમ ઓટોમેશન સ્ક્રિપ્ટનો ડ્રાફ્ટ આપે છે. પરંતુ અહીં આ મોડ્યુલની કેન્દ્રીય ચેતવણી ફરીથી અમલમાં આવે છે: UI ટેસ્ટ કોડ કે જે AI ઉત્પન્ન કરે છે તે ઘણીવાર નાજુક પરીક્ષણો હોઈ શકે છે જે "લીલો પ્રકાશ કરે છે પરંતુ ખોટી વસ્તુની ચકાસણી કરે છે" અથવા પવનમાં ફફડાટ કરે છે. તમારું કાર્ય આ કોડને ચલાવવાનું નથી, પરંતુ તે ખરેખર યોગ્ય વસ્તુની મજબૂતીથી ચકાસણી કરે છે તેની ખાતરી કરવાનું છે.
આ એકમમાં, અમારું લક્ષ્ય એઆઈ સાથે મજબૂત, જાળવવા યોગ્ય અને ખરેખર માન્ય UI પરીક્ષણોનું ઉત્પાદન કરવાનો છે; તમે નાજુક પરીક્ષણો ટાળવાનું શીખી શકશો.
નક્કર UI પરીક્ષણના ત્રણ સ્તંભો
1. યોગ્ય તત્વ લોકેટર. પરીક્ષણ પૃષ્ઠ પર તત્વ શોધવા માટે પસંદગીકારનો ઉપયોગ કરે છે. AI ઘણીવાર બરડ પસંદગીકારોનું ઉત્પાદન કરે છે: લાંબા XPath પાથ (સરનામું પૃષ્ઠ બંધારણ પર વધુ પડતું નિર્ભર), CSS વર્ગના નામો પર આધારિત પસંદગીકારો (ડિઝાઇન બદલાય ત્યારે બ્રેક). મજબૂત રીત એ ડેટા-ટેસ્ટિડ જેવી સ્થિર વિશેષતાઓ છે જે વિકાસકર્તાએ પરીક્ષણ માટે ઉમેર્યા છે. આને AI પર સ્પષ્ટપણે લાદવો.
2. સ્પષ્ટ રાહ જુઓ. UI પરીક્ષણમાં નબળાઈનો નંબર એક સ્ત્રોત સમય છે. સતત ઊંઘ (3) (આંધળી રાહ) એ ખરાબ પ્રથા છે: ક્યારેક તે પૂરતું નથી, ક્યારેક તે સમયનો વ્યય કરે છે. સાચો રસ્તો સ્પષ્ટ પ્રતીક્ષાનો ઉપયોગ કરવાનો છે, જે કહે છે કે "આ તત્વ દેખાય ત્યાં સુધી રાહ જુઓ". નાટ્યકાર આ મોટે ભાગે આપોઆપ કરે છે; સેલેનિયમમાં તમારે સ્પષ્ટપણે તેની વિનંતી કરવી આવશ્યક છે.
3. અર્થપૂર્ણ નિવેદન. પરીક્ષણમાં વપરાશકર્તા ખરેખર જે પરિણામ જોશે તે ચકાસવું જોઈએ — જેમ કે "સ્ક્રીન પર ઓર્ડર નંબર દેખાયો," માત્ર "પૃષ્ઠ લોડ થયેલ" નહીં. જો AI દ્વારા ઉત્પાદિત પરીક્ષણમાં કોઈ નિવેદન ન હોય અથવા બિનમહત્વપૂર્ણ હોય, તો તે પરીક્ષણ સ્યુડો-પાસ (1મું એકમ) ઉત્પન્ન કરે છે.
સાવધાન: જ્યારે તમે પહેલીવાર AI-જનરેટેડ UI ટેસ્ટ જુઓ, ત્યારે વધુમાં વધુ ત્રણ બાબતો તપાસો: શું પસંદગીકારો પ્રતિબદ્ધ છે (ડેટા-ટેસ્ટિડ), રાહ જુએ છે (કોઈ બ્લાઈન્ડ સ્લીપ નથી), અને શું દાવો વાસ્તવિક વપરાશકર્તા પરિણામની ચકાસણી કરે છે? જો આ ત્રણ બરાબર છે, તો ટેસ્ટ કદાચ નક્કર છે.
પૃષ્ઠ ઑબ્જેક્ટ મોડલ
જેમ જેમ કસોટીઓ મોટી થતી જાય છે તેમ તેમ દરેક કસોટીની અંદર પસંદગીકારોને લખવું એ જાળવણીનું દુઃસ્વપ્ન બની જાય છે. પેજ ઑબ્જેક્ટ મોડલ (POM — ડિઝાઇન પેટર્ન કે જે દરેક પૃષ્ઠ/સ્ક્રીન માટે પસંદગીકારો અને ક્રિયાઓને એક વર્ગમાં એકત્રિત કરે છે) પસંદગીકારને એક જગ્યાએ રાખે છે; જ્યારે ઇન્ટરફેસ બદલાય છે, ત્યારે તમે તેને એક ફાઇલમાં અપડેટ કરો છો. AI ને POM સ્ટ્રક્ચરમાં પરીક્ષણો પ્રત્યક્ષ કરવાને બદલે ઉત્પન્ન કરવા દો; આ જાળવણીને ધરમૂળથી સરળ બનાવે છે.
નબળા પ્રોમ્પ્ટ / મજબૂત પ્રોમ્પ્ટ
નબળા: "લોગિન પૃષ્ઠ માટે સેલેનિયમ પરીક્ષણ લખો."
સશક્ત: "નાટકકાર (ટાઈપસ્ક્રીપ્ટ) સાથે લોગિન ફ્લો ટેસ્ટ લખો. પસંદગીકારો માત્ર ડેટા-ટેસ્ટિડનો ઉપયોગ કરે છે; વપરાશકર્તા શું જુએ છે તેના નિયંત્રણનો ઉપયોગ કરતા નથી, પૃષ્ઠ શીર્ષકનો નહીં."
શક્તિશાળી પ્રોમ્પ્ટ; આ ટૂલ ભાષા, પસંદગીકાર નીતિ, રાહ વ્યૂહરચના, આર્કિટેક્ચર (POM) અને અભિવ્યક્ત દાવો અપેક્ષા આપે છે.
ટેસ્ટ ડેટા અને પર્યાવરણની સ્વતંત્રતા
એક નક્કર UI પરીક્ષણ માત્ર યોગ્ય રીતે લખવામાં આવતું નથી, પરંતુ તેનો પોતાનો ટેસ્ટ ડેટા પણ બનાવે છે અને સાફ કરે છે. AI-જનરેટેડ પરીક્ષણો ઘણીવાર એવા વપરાશકર્તા અથવા રેકોર્ડ સાથે લિંક કરે છે જે પર્યાવરણમાં પહેલેથી જ અસ્તિત્વમાં હોવાનું માનવામાં આવે છે ("એડમિન વપરાશકર્તા તરીકે લૉગ ઇન કરો"). આ ધારણા તૂટે છે જ્યારે પરીક્ષણ અન્ય વાતાવરણમાં અથવા અન્ય પરીક્ષણ પછી ચાલે છે (એકમ 9 માં ઓર્ડર નિર્ભરતાની સમસ્યા). સત્ય એ છે કે દરેક ટેસ્ટ ટેસ્ટની શરૂઆતમાં જરૂરી ડેટા બનાવે છે (અથવા તેને API કૉલ સાથે તૈયાર કરે છે) અને અંતે તેને સાફ કરે છે. AI ને સ્પષ્ટપણે સૂચના આપો કે "કોઈપણ ડેટા સેટ કરો કે જેના પર આ ટેસ્ટ ટેસ્ટની અંદર આધાર રાખે છે; બહારથી તૈયાર ડેટા ધારે નહીં."
અન્ય નિર્ણાયક મુદ્દો એ છે કે વાસ્તવિક વપરાશકર્તા ડેટા સાથે UI પરીક્ષણ ન કરવું. જો પ્રોડક્શન ડેટાબેઝ કોપીનો ઉપયોગ પરીક્ષણ વાતાવરણમાં કરવામાં આવે છે, તો આ રેકોર્ડ વાસ્તવિક વ્યક્તિઓનો ડેટા છે; સ્ક્રીનશૉટ્સ અને ટેસ્ટ રેકોર્ડિંગ આ ડેટાને જાહેર કરી શકે છે. કૃત્રિમ (કાલ્પનિક) પરીક્ષણ એકાઉન્ટ્સનો ઉપયોગ કરો; તે બંને ગોપનીયતાનું રક્ષણ કરે છે અને પરીક્ષણોને પુનઃઉત્પાદનક્ષમ બનાવે છે. વાસ્તવિક ગ્રાહક ખાતા સાથે "ઓર્ડર કેન્સલેશન" પરીક્ષણ હાથ ધરવું એ નૈતિક અને ઓપરેશનલ બંને પ્રકારની ભૂલ છે.
ટીપ: UI પરીક્ષણો શક્ય તેટલા ઓછા રાખો; વાસ્તવિક ચકાસણી API અને એકમ પરીક્ષણો પર છોડી દો, જે ઝડપી અને સ્થિર છે. UI પરીક્ષણ ખર્ચાળ અને બરડ છે — તેનો ઉપયોગ ફક્ત ખરેખર એન્ડ-ટુ-એન્ડ યુઝર ફ્લો (ટેસ્ટ પિરામિડ લોજિક) ને માન્ય કરવા માટે કરો.
વાહન સરખામણી
લક્ષણ
સેલેનિયમ
નાટ્યકાર
સાયપ્રસ
ભાષાઓ
Java, C#, Python, JS
JS/TS, Python, .NET, Java
JavaScript/TypeScript
ઓટો સ્ટેન્ડબાય
ના (હાથથી)
હા (મજબૂત)
હા
મલ્ટી બ્રાઉઝર
પહોળું
ક્રોમિયમ/ફાયરફોક્સ/વેબકિટ
ક્રોમિયમ-પ્રબળ
બરડપણું વલણ
ઉચ્ચ (મેન્યુઅલ સ્ટેન્ડબાય)
નીચું
નીચું
શીખવાની સરળતા
મધ્યમ
સરળ
સરળ
સમાંતર કામગીરી
ગ્રીડ જરૂરી છે
બિલ્ટ-ઇન
નિવાસી/ચૂકવણી
AI થી કોડની વિનંતી કરતી વખતે, સ્પષ્ટપણે જણાવો કે તે કયા વાહનનું છે; નહિંતર, તે ગૂંચવણમાં મૂકે છે, બિન-કાર્યકારી કોડ પેદા કરી શકે છે.
ચાર નકલ કરી શકાય તેવા નમૂનાઓ
1) સોલિડ UI ટેસ્ટ જનરેશન:
તમારી ભૂમિકા: વરિષ્ઠ પરીક્ષણ ઓટોમેશન એન્જિનિયર. નીચેના પ્રવાહ માટે [ટૂલ + ભાષા] સાથે પરીક્ષણો લખો: [પ્રવાહ]. નિયમો:- પસંદગીકારો માત્ર ડેટા-ટેસ્ટિડ; XPath/CSS-ક્લાસનો ઉપયોગ કરવો. - કોઈ અંધ ઊંઘ; સ્પષ્ટ/સ્વચાલિત રાહનો ઉપયોગ કરો. - પેજ ઓબ્જેક્ટ મોડલ લાગુ કરો. - દરેક દાવાને વાસ્તવિક વપરાશકર્તા પરિણામ ચકાસવા દો. તમે કયા સ્વીકૃતિ માપદંડોને માન્ય કરી રહ્યાં છો તે દરેક પરીક્ષણની શરૂઆતમાં ટિપ્પણી કરો.
2) નાજુકતા નિયંત્રણ:
બરડતા માટે નીચેની UI ટેસ્ટની તપાસ કરો:- શું ત્યાં કોઈ અસ્થિર પસંદગીકાર છે (લાંબા
3) પૃષ્ઠ ઑબ્જેક્ટમાં રૂપાંતર:
નીચેના સાદા ટેસ્ટ કોડને પેજ ઑબ્જેક્ટ મોડલ સ્ટ્રક્ચરમાં કન્વર્ટ કરો. પસંદગીકારો અને ક્રિયાઓને પૃષ્ઠ વર્ગોમાં ખસેડો; પરીક્ષણ ફાઇલને ફક્ત દૃશ્ય પ્રવાહ વાંચવા દો. [ટૂલ/ભાષા].કોડ: [કોડ પેસ્ટ કરો]
4) સ્યુડો-સંક્રમણ સાબિતી:
સાબિત કરો કે આ UI પરીક્ષણ વાસ્તવમાં માન્ય કરે છે: હું એપ્લિકેશન કોડમાં કયો એકલ ફેરફાર કરું જે આ પરીક્ષણને RED કરશે? જો તમે પરીક્ષણને તોડી નાખે તેવો ફેરફાર શોધી શકતા નથી, તો પરીક્ષણ અપૂરતું છે; ખૂટતા દાવાઓ ઉમેરો. ટેસ્ટ: [પેસ્ટ ટેસ્ટ]
ત્રણ નાના કેસો
કેસ 1 - નાજુક પસંદગીકારથી મુક્તિ. AI સાથે એક ટીમ દ્વારા ઉત્પાદિત 40 પરીક્ષણોમાંથી, 70% ઈન્ટરફેસ અપડેટ પછી તૂટી ગયા હતા; તેમાંથી કોઈ પણ વાસ્તવિક ભૂલો ન હતી, તે બધા નાજુક XPath પસંદગીકારો હતા. ટીમે "ફ્રેજીલીટી ચેક" ટેમ્પલેટ સાથે ટેસ્ટને ડેટા-ટેસ્ટીડ બેઝમાં રૂપાંતરિત કર્યું. આગામી ત્રણ ઈન્ટરફેસ અપડેટ્સમાં, ખોટા બ્રેક્સની સંખ્યા ઘટીને શૂન્ય થઈ ગઈ; જાળવણી સમય દર અઠવાડિયે 6 કલાકથી ઘટીને 30 મિનિટ થયો.
કેસ 2 — નકલી-પાસિંગ UI ટેસ્ટ. AI એ "કાર્ટમાં ઉમેરો" પરીક્ષણનું ઉત્પાદન કર્યું; ટેસ્ટ લીલો હતો. જ્યારે "નકલી-પ્રૂફ-ઓફ-પેસેજ" ટેમ્પલેટ ચલાવવામાં આવ્યું હતું, ત્યારે પરીક્ષણ ફક્ત બટન ક્લિક અને પૃષ્ઠ શીર્ષકને તપાસવા માટે દેખાય છે, કાર્ટ કાઉન્ટર વધ્યું છે કે નહીં તેની ક્યારેય ચકાસણી કરતું નથી. જો કાર્ટ તર્ક સંપૂર્ણપણે તૂટી ગયો હતો, તો પણ પરીક્ષા પાસ થઈ. સાચું નિવેદન ઉમેર્યું (કાર્ટ બેજ "1" છે).
કેસ 3 - બ્લાઇન્ડ વેઇટિંગ ટ્રેપ. AI દ્વારા ઉત્પાદિત સેલેનિયમ પરીક્ષણમાં, દરેક પગલા પછી ઊંઘ (2) હતી; 60 પરીક્ષણોમાં 14 મિનિટનો સમય લાગ્યો અને હજુ પણ ક્યારેક ક્યારેક તૂટી ગયો. ઓપન વેઇટ પર સ્વિચ કર્યા પછી (તત્વ ક્લિક કરી શકાય તેવી રાહ જુઓ) સમય ઘટીને 5 મિનિટ થઈ ગયો અને બરડપણું અદૃશ્ય થઈ ગયું. આંધળી રાહ ધીમી અને અવિશ્વસનીય બંને હતી.
સામાન્ય ભૂલો
- નાજુક પસંદગીકારો સાથે સંમત. AI દ્વારા જનરેટ કરાયેલા લાંબા XPathsનો ઉપયોગ કરીને જેમ છે; પ્રથમ ઇન્ટરફેસ ફેરફાર વખતે ટેસ્ટ ક્રેશ થાય છે.
- આંધળી 'ઊંઘ' છોડીને. નિશ્ચિત પ્રતીક્ષા સાથે સમયને "ઉકેલવું"; બંને ધીમા અને અનિર્ણાયક.
- તુચ્છ દાવો. ફક્ત ચકાસો કે પૃષ્ઠ લોડ થયું છે; વાસ્તવિક વપરાશકર્તા પરિણામ (નકલી-પાસ) તપાસતા નથી.
- POM વિના વૃદ્ધિ કરો. દરેક પરીક્ષણ માટે પસંદગીકારોનું વિતરણ કરો; જ્યારે ઇન્ટરફેસ બદલાય ત્યારે ડઝનેક ફાઇલોને મેન્યુઅલી અપડેટ કરવી.
- સાધનનો ઉલ્લેખ નથી. તમને કયું સાધન/ભાષા જોઈએ છે તે એઆઈને ન જણાવવું; અવ્યવસ્થિત, બિન-કાર્યકારી કોડ મેળવવો.
- જ્યારે તમે જનરેટ કરેલ કોડ ચલાવો અને પાસ કરો ત્યારે વિશ્વાસ કરવો. કોડ ભંગ કરીને પરીક્ષણ નથી.
સારાંશમાં
UI પરીક્ષણ ઓટોમેશન પ્રોગ્રામ સાથે વાસ્તવિક બ્રાઉઝર ચલાવીને વપરાશકર્તાના વર્તનને ચકાસે છે. AI આ કોડ ઝડપથી જનરેટ કરે છે, પરંતુ ત્યાં બે મોટી ખામીઓ છે: બરડ પરીક્ષણો (ખરાબ પસંદગીકાર, આંધળી રાહ જુઓ) અને નકલી-પાસિંગ પરીક્ષણો (અપૂર્ણ/તુચ્છ ભારપૂર્વક). નક્કર UI પરીક્ષણના ત્રણ સ્તંભો કમિટ સિલેક્ટર (ડેટા-ટેસ્ટિડ), સ્પષ્ટ પ્રતીક્ષા છે અને વાસ્તવિક વપરાશકર્તા પરિણામની ચકાસણી કરે છે. પેજ ઑબ્જેક્ટ મૉડલમાં જનરેટ થયેલા પરીક્ષણો ધરમૂળથી જાળવણીને સરળ બનાવે છે. દરેક જનરેટેડ ટેસ્ટને "કયો ફેરફાર આને તોડશે?" પ્રશ્ન સાથે પરીક્ષણ કરો.
એપ્લિકેશન કાર્ય
તમારા પોતાના પ્રોજેક્ટમાંથી વપરાશકર્તા પ્રવાહ પસંદ કરો (દા.ત. લોગિન અથવા શોધ). "મજબૂત UI ટેસ્ટ જનરેશન" ટેમ્પ્લેટ સાથે AI લેખન પરીક્ષણો લો. પછી: (1) પસંદગીકારોને તપાસો અને ઠીક કરો અને "ફ્રેજિલિટી ચેક" સાથે રાહ જુઓ, (2) સાબિત કરો કે દરેક પરીક્ષણ ખરેખર "સ્યુડો-પાસ પ્રૂફ" સાથે માન્ય કરે છે, (3) કોડ તોડો અને અવલોકન કરો કે પરીક્ષણ લાલ થઈ ગયું છે. ઉત્પાદિત અને સુધારેલ પરીક્ષણોની સંખ્યા અને તમને મળેલી નબળાઈઓ અને સ્યુડો-પાસની સંખ્યાની જાણ કરો.
ચેકલિસ્ટ
- [ ] મેં AI ને ટૂલ, ભાષા, પસંદગીકાર નીતિ અને આર્કિટેક્ચર (POM) સ્પષ્ટ રીતે આપ્યું છે.
- [ ] મેં ચકાસ્યું કે પસંદગીકારો ડેટા-ટેસ્ટીડ છે.
- [ ] મેં અંધ ઊંઘને બદલે સ્પષ્ટ/સ્વચાલિત રાહનો ઉપયોગ કરવાની ખાતરી કરી છે.
- [ ] મેં તપાસ્યું કે દરેક દાવો વાસ્તવિક વપરાશકર્તા પરિણામની ચકાસણી કરે છે.
- [ ] મેં કોડ તોડીને દરેક ટેસ્ટનું પરીક્ષણ કર્યું; મેં જોયું કે તે લાલ થઈ ગયું છે.
- [ ] મેં પેજ ઑબ્જેક્ટ મોડલ સ્ટ્રક્ચરમાં પરીક્ષણો એકત્રિત કર્યા.