Playwright 1.56 માં ત્રણ બિલ્ટ-ઇન AI એજન્ટ્સ સાથે આવે છે જે ટેસ્ટ સૂટનું આયોજન કરે છે, સંબંધિત TypeScript સ્ક્રિપ્ટ્સ લખે છે, અને ત્વરિત રીતે બગડેલા લોકેટર્સ (locators) ને રિપેર કરે છે. પરિણામ: મેન્યુઅલ ટેસ્ટિંગની મહેનત હવે AI-સહાયિત વર્કફ્લોમાં બદલાઈ જાય છે.
આ ફેરફાર શા માટે મહત્વપૂર્ણ છે
ઓટોમેશન એન્જિનિયરો લાંબા સમયથી એક પુનરાવર્તિત લૂપ અનુસરી રહ્યા છે: જરૂરિયાતોને ટેસ્ટ કેસમાં રૂપાંતરિત કરવી, સ્ક્રિપ્ટ્સ હેન્ડ-કોડ કરવી, તેને ચલાવવી, અને પછી જ્યારે પણ UI બદલાય ત્યારે અનિશ્ચિત (flaky) સિલેક્ટર્સ પાછળ દોડવું. મેન્ટેનન્સનો વધારાનો બોજ ઓટોમેશન દ્વારા બચાવેલા સમય કરતા પણ વધી શકે છે, ખાસ કરીને ઝડપથી બદલાતા ફ્રન્ટ-એન્ડ્સમાં. ટેસ્ટિંગ ફ્રેમવર્કમાં સીધા જ AI એજન્ટ્સને સામેલ કરીને, Playwright "ફિક્સ-એન્ડ-રન" ચક્રને ઘટાડે છે અને એન્જિનિયરોને સિલેક્ટર શોધવાને બદલે ઉચ્ચ-સ્તરની ટેસ્ટ વ્યૂહરચના પર ધ્યાન કેન્દ્રિત કરવા દે છે.
ત્રણેય એજન્ટોની સમજૂતી
- Planner Agent – એપ્લિકેશન શું કરવું જોઈએ તેનું નેચરલ-લેંગ્વેજ (કુદરતી ભાષા) વર્ણન લે છે, લાઈવ સાઈટને એક્સપ્લોર કરે છે, અને એક સ્ટ્રક્ચર્ડ Markdown પ્લાન આઉટપુટ કરે છે. આ પ્લાન પ્રાથમિક યુઝર ફ્લો અને એજ-કેસ (edge-case) પરિસ્થિતિઓની યાદી આપે છે, જે કોઈપણ કોડ લખતા પહેલા એક સ્પષ્ટ બ્લુપ્રિન્ટ પૂરી પાડે છે.
- Generator Agent – Markdown પ્લાનનો ઉપયોગ કરીને એક્ઝિક્યુટેબલ TypeScript ટેસ્ટ કોડ બનાવે છે. તે સિલેક્ટર્સ સ્થિર છે કે નહીં તે ચકાસવા માટે ચાલતા બ્રાઉઝર સાથે વાતચીત કરે છે, અને જો સૂચના આપવામાં આવે તો તે Page Object Model (એક ડિઝાઇન પેટર્ન જે પેજ સ્ટ્રક્ચરને ટેસ્ટ લોજિકથી અલગ કરે છે) ને અનુસરી શકે છે.
- Healer Agent – ટેસ્ટ રનનું મોનિટરિંગ કરે છે; જ્યારે કોઈ નિષ્ફળતા UI ફેરફારને કારણે થાય છે, ત્યારે તે નિષ્ફળ સ્ટેપ્સને ફરીથી રન કરે છે, અપડેટ કરેલા DOM ની તપાસ કરે છે, અને સુધારેલા સિલેક્ટર અથવા લોકેટરનું સૂચન કરે છે. આ સૂચન એક ડ્રાફ્ટ પેચ તરીકે દેખાય છે જેને ડેવલપર સ્વીકારી શકે છે અથવા તેમાં ફેરફાર કરી શકે છે.
આ એજન્ટો "એજન્ટિક લૂપ" (agentic loop) માં કામ કરે છે: Planner → Generator → Healer. દરેક સ્ટેપ પછીના સ્ટેપને ઇનપુટ આપે છે, જેનાથી એક સેલ્ફ-એડજસ્ટિંગ પાઇપલાઇન બને છે જે ટેસ્ટ હેઠળની એપ્લિકેશન સાથે સિંક રહે છે.
તે સામાન્ય AI ટૂલ્સથી કેવી રીતે અલગ છે
ચેટ-સ્ટાઇલ મોડલ્સ અથવા કોડ-કમ્પ્લીશન એક્સટેન્શન સ્નિપેટ્સ બનાવી શકે છે, પરંતુ તેમની પાસે લાઈવ DOM અને ચોક્કસ પ્રોજેક્ટ કોન્ફિગરેશનની સીધી એક્સેસ હોતી નથી. Playwright ના એજન્ટ્સ Model Context Protocol નો ઉપયોગ કરે છે જે વર્તમાન પેજ સ્ટ્રક્ચર અને ટેસ્ટ ફ્રેમવર્ક સેટિંગ્સને મોડલમાં સ્ટ્રીમ કરે છે, જેનાથી AI એ ચોક્કસ એલિમેન્ટ્સ વિશે તર્ક કરી શકે છે જેની સાથે તે ઇન્ટરેક્ટ કરશે. તે જે કોડ જનરેટ કરે છે તે માત્ર સિન્ટેક્ટિકલી (syntactically) સાચો જ નથી, પરંતુ જનરેશન સમયે વાસ્તવિક UI સાથે જોડાયેલો પણ હોય છે.
થોડી કમાન્ડ્સ સાથે શરૂઆત કરો
- Node પ્રોજેક્ટ સેટઅપ કરો અને Playwright ને ડિપેન્ડન્સી તરીકે ઉમેરો.
- તમારા એડિટરની અંદર AI લૂપ શરૂ કરવા માટે
npx playwright init-agents --loop=vscodeરન કરો. - એક મિનિમલ "seed" ટેસ્ટ લખો જે એપ્લિકેશન લોડ કરે; આ એજન્ટોને એક ચોક્કસ સંદર્ભ (context) આપે છે.
- Planner ને ટ્રિગર કરવા માટે નેચરલ-લેંગ્વેજ પ્રોમ્પ્ટ્સ (દા.ત., “Create a checkout flow covering discount codes”) આપો, Generator ને સ્ક્રિપ્ટ બનાવવા દો, અને Healer ને તેને હેલ્ધી રાખવા દો.
એજન્ટ્સને વધુ સારી રીતે કામ કરવા માટેની ટિપ્સ
- સ્પષ્ટ seed ટેસ્ટ – પ્રારંભિક ટેસ્ટ વિશ્વસનીય રીતે એપ લોન્ચ કરે છે અને મુખ્ય UI એલિમેન્ટ્સને એક્સપોઝ કરે છે તે રીતે હોવી જોઈએ; અસ્પષ્ટ એન્ટ્રી પોઈન્ટ્સ Planner ને મૂંઝવણમાં મૂકી શકે છે.
- સ્ટ્રક્ચર્ડ seed ડેટા – અપેક્ષિત ઇનપુટ્સનું વર્ણન કરતા JSON ફિક્સ્ચર્સ (fixtures) પૂરા પાડવાથી Generator ને યોગ્ય સિલેક્ટર્સ પસંદ કરવામાં મદદ મળે છે.
- Page Object Model માટે પૂછો – Generator ને સ્પષ્ટપણે પેજ ઓબ્જેક્ટ્સ બનાવવા માટે કહેવાથી વધુ સ્વચ્છ અને મેન્ટેનેબલ કોડ મળે છે.
- AI આઉટપુટને ડ્રાફ્ટ તરીકે ગણો – કોડ કમિટ કરતા પહેલા જનરેટ કરેલી સ્ક્રિપ્ટ્સની સમીક્ષા કરો; એજન્ટ્સ હજુ પણ બિઝનેસ-લોજિકની બારીકીઓ ચૂકી શકે છે અથવા વધુ પડતા જનરિક સિલેક્ટર્સ બનાવી શકે છે.