നേട്ടങ്ങൾ:
- ഡാറ്റ-ടെസ്റ്റിഡ്, ഓപ്പൺ വെയിറ്റ്, യഥാർത്ഥ ഉപയോക്തൃ ഫലം സ്ഥിരീകരിക്കുന്നുണ്ടെന്ന് ഉറപ്പ് എന്നിവ ഉൾപ്പെടെ, കൃത്രിമ ബുദ്ധി ഉപയോഗിച്ച് ശക്തമായ യുഐ ടെസ്റ്റ് കോഡ് നിർമ്മിക്കാനുള്ള കഴിവ്
- ദുർബലമായ പരിശോധനകൾ ഒഴിവാക്കാനുള്ള കഴിവ് (മോശം സെലക്ടർ, അന്ധമായ കാത്തിരിപ്പ്) കൂടാതെ പേജ് ഒബ്ജക്റ്റ് മോഡൽ ഘടനയിൽ പരിശോധനകൾ എളുപ്പമാക്കുക
- കോഡ് തകർത്ത് നിർമ്മിക്കുന്ന എല്ലാ യുഐ ടെസ്റ്റുകളും പരീക്ഷിക്കാനും വ്യാജ പാസായ ടെസ്റ്റുകൾ കണ്ടെത്തി പരിഹരിക്കാനുമുള്ള കഴിവ്
ഒരു ബ്രൗസറിൽ ഒരു ഉപയോക്താവ് നടത്തുന്ന എല്ലാ ക്ലിക്കുകളും, ഓരോ ഫോം ഫില്ലും, ഓരോ പേജ് സംക്രമണവും കൈകൊണ്ട് വീണ്ടും വീണ്ടും പരീക്ഷിക്കാൻ കഴിയില്ല - അതുകൊണ്ടാണ് യുഐ ടെസ്റ്റ് ഓട്ടോമേഷൻ (ഉപയോക്തൃ ഇൻ്റർഫേസ്; ഈ ടെസ്റ്റുകൾ ഒരു യഥാർത്ഥ ബ്രൗസറിനെ പ്രോഗ്രമാറ്റിക്കായി ഡ്രൈവ് ചെയ്യുന്നതിലൂടെ ഉപയോക്തൃ പെരുമാറ്റത്തെ അനുകരിക്കുന്നു) നിലവിലുണ്ട്. സെലിനിയം, പ്ലേറൈറ്റ്, സൈപ്രസ് എന്നിവയാണ് ഈ ജോലിക്കുള്ള ഏറ്റവും സാധാരണമായ ഉപകരണങ്ങൾ. ഈ ഉപകരണങ്ങൾക്കായി കോഡ് എഴുതുന്നതിൽ ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് (AI) വളരെ വൈദഗ്ധ്യമുള്ളതാണ്: നിങ്ങൾ ഒരു ടെസ്റ്റ് കേസ് വിവരിക്കുന്നു, AI നിങ്ങൾക്ക് ഒരു പ്രവർത്തനക്ഷമമായ ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റിൻ്റെ ഡ്രാഫ്റ്റ് നൽകുന്നു. എന്നാൽ ഇവിടെ ഈ മൊഡ്യൂളിൻ്റെ കേന്ദ്ര മുന്നറിയിപ്പ് വീണ്ടും പ്രാബല്യത്തിൽ വരുന്നു: AI നിർമ്മിക്കുന്ന UI ടെസ്റ്റ് കോഡ് പലപ്പോഴും "പച്ച പ്രകാശിപ്പിക്കുകയും തെറ്റായ കാര്യം സ്ഥിരീകരിക്കുകയും" അല്ലെങ്കിൽ കാറ്റിൽ പറക്കുന്ന ദുർബലമായ പരിശോധനകളായിരിക്കാം. നിങ്ങളുടെ ജോലി ഈ കോഡ് പ്രവർത്തിപ്പിക്കലല്ല, മറിച്ച് അത് യഥാർത്ഥത്തിൽ ശരിയായ കാര്യം സ്ഥിരീകരിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക എന്നതാണ്.
ഈ യൂണിറ്റിൽ, AI ഉപയോഗിച്ച് കരുത്തുറ്റതും പരിപാലിക്കാവുന്നതും യഥാർത്ഥത്തിൽ സാധൂകരിക്കുന്നതുമായ UI ടെസ്റ്റുകൾ നിർമ്മിക്കാൻ ഞങ്ങൾ ലക്ഷ്യമിടുന്നു; ദുർബലമായ പരിശോധനകൾ ഒഴിവാക്കാൻ നിങ്ങൾ പഠിക്കും.
സോളിഡ് യുഐ ടെസ്റ്റിംഗിൻ്റെ മൂന്ന് തൂണുകൾ
1. ശരിയായ മൂലക ലൊക്കേറ്റർ. പേജിലെ ഘടകം കണ്ടെത്താൻ ഒരു ടെസ്റ്റ് ഒരു സെലക്ടർ ഉപയോഗിക്കുന്നു. AI പലപ്പോഴും പൊട്ടുന്ന സെലക്ടറുകൾ നിർമ്മിക്കുന്നു: നീണ്ട XPath പാതകൾ (വിലാസം പേജ് ഘടനയെ അമിതമായി ആശ്രയിക്കുന്നു), CSS ക്ലാസ് പേരുകൾ അടിസ്ഥാനമാക്കിയുള്ള സെലക്ടറുകൾ (ഡിസൈൻ മാറുമ്പോൾ ബ്രേക്ക്). ഡെവലപ്പർ ടെസ്റ്റിംഗിനായി ചേർത്ത ഡാറ്റ-ടെസ്റ്റിഡ് പോലെയുള്ള സ്ഥിരതയുള്ള ആട്രിബ്യൂട്ടുകളാണ് ശക്തമായ മാർഗം. ഇത് AI-യിൽ വ്യക്തമായി അടിച്ചേൽപ്പിക്കുക.
2. വ്യക്തമായ കാത്തിരിപ്പ്. UI ടെസ്റ്റിംഗിലെ അപകടസാധ്യതയുടെ ഒന്നാമത്തെ ഉറവിടം സമയമാണ്. നിരന്തരമായ ഉറക്കം (3) (അന്ധമായ കാത്തിരിപ്പ്) ഒരു മോശം പരിശീലനമാണ്: ചിലപ്പോൾ ഇത് മതിയാകില്ല, ചിലപ്പോൾ സമയം പാഴാക്കുന്നു. "ഈ ഘടകം ദൃശ്യമാകുന്നതുവരെ കാത്തിരിക്കുക" എന്ന് പറയുന്ന വ്യക്തമായ കാത്തിരിപ്പാണ് ശരിയായ മാർഗം. നാടകകൃത്ത് ഇത് മിക്കവാറും യാന്ത്രികമായി ചെയ്യുന്നു; സെലിനിയത്തിൽ നിങ്ങൾ അത് വ്യക്തമായി അഭ്യർത്ഥിക്കണം.
3. അർത്ഥവത്തായ അവകാശവാദം. "സ്ക്രീനിൽ ഓർഡർ നമ്പർ പ്രത്യക്ഷപ്പെട്ടത്" പോലെ, "പേജ് ലോഡുചെയ്തു" എന്നതു പോലെ, ഉപയോക്താവ് യഥാർത്ഥത്തിൽ കാണുന്ന ഫലം പരിശോധന പരിശോധിക്കണം. AI നിർമ്മിക്കുന്ന ടെസ്റ്റിന് ഒരു ഉറപ്പ് ഇല്ലെങ്കിലോ അപ്രധാനമാണെങ്കിൽ, ആ ടെസ്റ്റ് ഒരു വ്യാജ പാസ് (1st യൂണിറ്റ്) ഉണ്ടാക്കുന്നു.
മുന്നറിയിപ്പ്: നിങ്ങൾ ആദ്യം ഒരു AI- ജനറേറ്റഡ് യുഐ ടെസ്റ്റ് കാണുമ്പോൾ, പരമാവധി മൂന്ന് കാര്യങ്ങൾ പരിശോധിക്കുക: സെലക്ടർമാർ പ്രതിജ്ഞാബദ്ധരാണോ (ഡാറ്റ-ടെസ്റ്റിഡ്), കാത്തിരിക്കുന്നു (അന്ധമായ ഉറക്കം ഇല്ല), കൂടാതെ ഉറപ്പ് യഥാർത്ഥ ഉപയോക്തൃ ഫലം സ്ഥിരീകരിക്കുന്നുണ്ടോ? ഇവ മൂന്നും ശരിയാണെങ്കിൽ, പരിശോധന ഒരുപക്ഷേ ഉറച്ചതാണ്.
പേജ് ഒബ്ജക്റ്റ് മോഡൽ
ടെസ്റ്റുകൾ വലുതാകുമ്പോൾ, ഓരോ ടെസ്റ്റിനുള്ളിലും സെലക്ടറുകൾ എഴുതുന്നത് ഒരു പരിപാലന പേടിസ്വപ്നമായി മാറുന്നു. പേജ് ഒബ്ജക്റ്റ് മോഡൽ (POM — ഓരോ പേജിനും/സ്ക്രീനിനുമുള്ള സെലക്ടറുകളും പ്രവർത്തനങ്ങളും ഒരൊറ്റ ക്ലാസിലേക്ക് ശേഖരിക്കുന്ന ഡിസൈൻ പാറ്റേൺ) സെലക്ടറെ ഒരിടത്ത് നിലനിർത്തുന്നു; ഇൻ്റർഫേസ് മാറുമ്പോൾ, നിങ്ങൾ അത് ഒരൊറ്റ ഫയലിൽ അപ്ഡേറ്റ് ചെയ്യുന്നു. നേരിട്ടല്ല, ഒരു POM ഘടനയിൽ ടെസ്റ്റുകൾ നിർമ്മിക്കാൻ AI യെ അനുവദിക്കുക; ഇത് അറ്റകുറ്റപ്പണികൾ സമൂലമായി എളുപ്പമാക്കുന്നു.
ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്
ദുർബലമായത്: "ലോഗിൻ പേജിനായി ഒരു സെലിനിയം ടെസ്റ്റ് എഴുതുക."
ശക്തമായത്: "Playwright (TypeScript) ഉപയോഗിച്ച് ഒരു ലോഗിൻ ഫ്ലോ ടെസ്റ്റ് എഴുതുക. സെലക്ടറുകൾ ഡാറ്റ-ടെസ്റ്റിഡ് മാത്രമേ ഉപയോഗിക്കൂ; ഉപയോക്താവ് കാണുന്നതിനെ നിയന്ത്രിക്കരുത്, പേജ് ശീർഷകമല്ല."
ശക്തമായ പ്രോംപ്റ്റ്; ഉപകരണം ഭാഷ, സെലക്ടർ നയം, കാത്തിരിപ്പ് തന്ത്രം, ആർക്കിടെക്ചർ (POM), പ്രകടമായ ഉറപ്പ് പ്രതീക്ഷ എന്നിവ നൽകുന്നു.
ഡാറ്റയും പരിസ്ഥിതി സ്വാതന്ത്ര്യവും പരിശോധിക്കുക
ഒരു സോളിഡ് യുഐ ടെസ്റ്റ് ശരിയായി എഴുതുക മാത്രമല്ല, സ്വന്തം ടെസ്റ്റ് ഡാറ്റ നിർമ്മിക്കുകയും വൃത്തിയാക്കുകയും ചെയ്യുന്നു. AI- ജനറേറ്റ് ചെയ്ത ടെസ്റ്റുകൾ പലപ്പോഴും പരിസ്ഥിതിയിൽ ഇതിനകം നിലവിലുണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്ന ഒരു ഉപയോക്താവുമായോ റെക്കോർഡുമായോ ലിങ്കുചെയ്യുന്നു (“അഡ്മിൻ ഉപയോക്താവായി ലോഗിൻ ചെയ്യുക”). മറ്റൊരു പരിതസ്ഥിതിയിൽ അല്ലെങ്കിൽ മറ്റൊരു ടെസ്റ്റിന് ശേഷം ടെസ്റ്റ് പ്രവർത്തിക്കുമ്പോൾ ഈ അനുമാനം തകരുന്നു (യൂണിറ്റ് 9 ലെ ഓർഡർ ഡിപൻഡൻസി പ്രശ്നം). ഓരോ ടെസ്റ്റും ടെസ്റ്റിൻ്റെ തുടക്കത്തിൽ ആവശ്യമായ ഡാറ്റ സൃഷ്ടിക്കുന്നു (അല്ലെങ്കിൽ ഒരു API കോൾ ഉപയോഗിച്ച് തയ്യാറാക്കുന്നു) അവസാനം അത് വൃത്തിയാക്കുന്നു എന്നതാണ് സത്യം. "ഈ ടെസ്റ്റ് ടെസ്റ്റിനുള്ളിൽ ആശ്രയിക്കുന്ന ഏതെങ്കിലും ഡാറ്റ സജ്ജീകരിക്കാൻ AI-യോട് വ്യക്തമായി നിർദ്ദേശിക്കുക; പുറത്ത് നിന്നുള്ള റെഡിമെയ്ഡ് ഡാറ്റ അനുമാനിക്കരുത്."
യഥാർത്ഥ ഉപയോക്തൃ ഡാറ്റ ഉപയോഗിച്ച് UI ടെസ്റ്റിംഗ് നടത്തരുത് എന്നതാണ് മറ്റൊരു പ്രധാന കാര്യം. ടെസ്റ്റ് പരിതസ്ഥിതിയിൽ ഒരു പ്രൊഡക്ഷൻ ഡാറ്റാബേസ് കോപ്പി ഉപയോഗിക്കുകയാണെങ്കിൽ, ഈ റെക്കോർഡുകൾ യഥാർത്ഥ വ്യക്തികളുടെ ഡാറ്റയാണ്; സ്ക്രീൻഷോട്ടുകളും ടെസ്റ്റ് റെക്കോർഡിംഗുകളും ഈ ഡാറ്റ വെളിപ്പെടുത്തിയേക്കാം. സിന്തറ്റിക് (സാങ്കൽപ്പിക) ടെസ്റ്റ് അക്കൗണ്ടുകൾ ഉപയോഗിക്കുക; ഇത് രണ്ടും രഹസ്യസ്വഭാവം സംരക്ഷിക്കുകയും പരിശോധനകൾ പുനരുൽപ്പാദിപ്പിക്കുകയും ചെയ്യുന്നു. ഒരു യഥാർത്ഥ ഉപഭോക്തൃ അക്കൗണ്ട് ഉപയോഗിച്ച് "ഓർഡർ റദ്ദാക്കൽ" പരിശോധന നടത്തുന്നത് ധാർമ്മികവും പ്രവർത്തനപരവുമായ ഒരു തെറ്റാണ്.
നുറുങ്ങ്: UI ടെസ്റ്റുകൾ കഴിയുന്നത്ര കുറച്ച് സൂക്ഷിക്കുക; വേഗതയേറിയതും സ്ഥിരതയുള്ളതുമായ API, യൂണിറ്റ് ടെസ്റ്റുകൾക്ക് യഥാർത്ഥ സ്ഥിരീകരണം വിടുക. യുഐ ടെസ്റ്റിംഗ് ചെലവേറിയതും പൊട്ടുന്നതുമാണ് - യഥാർത്ഥത്തിൽ എൻഡ്-ടു-എൻഡ് യൂസർ ഫ്ലോ (ടെസ്റ്റ് പിരമിഡ് ലോജിക്) സാധൂകരിക്കാൻ മാത്രം ഇത് ഉപയോഗിക്കുക.
വാഹന താരതമ്യം
സവിശേഷത
സെലിനിയം
നാടകകൃത്ത്
സൈപ്രസ്
ഭാഷകൾ
ജാവ, സി#, പൈത്തൺ, ജെഎസ്
JS/TS, പൈത്തൺ, .NET, ജാവ
JavaScript/TypeScript
ഓട്ടോ സ്റ്റാൻഡ്ബൈ
ഇല്ല (കൈകൊണ്ട്)
അതെ (ശക്തമായ)
അതെ
ഒന്നിലധികം ബ്രൗസർ
വിശാലമായ
Chromium/Firefox/WebKit
ക്രോമിയം-ആധിപത്യം
പൊട്ടുന്ന പ്രവണത
ഉയർന്നത് (മാനുവൽ സ്റ്റാൻഡ്ബൈ)
താഴ്ന്ന
താഴ്ന്ന
പഠിക്കാനുള്ള എളുപ്പം
ഇടത്തരം
എളുപ്പമുള്ള
എളുപ്പമുള്ള
സമാന്തര പ്രവർത്തനം
ഗ്രിഡ് ആവശ്യമാണ്
അന്തർനിർമ്മിത
താമസക്കാരൻ/പണമടച്ചത്
AI-യിൽ നിന്ന് ഒരു കോഡ് അഭ്യർത്ഥിക്കുമ്പോൾ, അത് ഏത് വാഹനത്തിൻ്റേതാണെന്ന് വ്യക്തമായി പ്രസ്താവിക്കുക; അല്ലെങ്കിൽ, അത് ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന, പ്രവർത്തിക്കാത്ത കോഡ് സൃഷ്ടിച്ചേക്കാം.
പകർത്താവുന്ന നാല് ടെംപ്ലേറ്റുകൾ
1) സോളിഡ് യുഐ ടെസ്റ്റ് ജനറേഷൻ:
നിങ്ങളുടെ റോൾ: സീനിയർ ടെസ്റ്റ് ഓട്ടോമേഷൻ എഞ്ചിനീയർ. ഇനിപ്പറയുന്ന ഫ്ലോയ്ക്കായി [ടൂൾ + ഭാഷ] ഉപയോഗിച്ച് ടെസ്റ്റുകൾ എഴുതുക: [ഫ്ലോ]. നിയമങ്ങൾ:- സെലക്ടർമാരുടെ ഡാറ്റ-ടെസ്റ്റിഡ് മാത്രം; XPath/CSS-ക്ലാസ് ഉപയോഗിക്കുന്നു. - അന്ധമായ ഉറക്കമില്ല; വ്യക്തമായ/യാന്ത്രിക കാത്തിരിപ്പ് ഉപയോഗിക്കുക. - പേജ് ഒബ്ജക്റ്റ് മോഡൽ പ്രയോഗിക്കുക. - യഥാർത്ഥ ഉപയോക്തൃ ഫലം പരിശോധിക്കാൻ ഓരോ അവകാശവാദത്തെയും അനുവദിക്കുക. നിങ്ങൾ മൂല്യനിർണ്ണയം നടത്തുന്ന സ്വീകാര്യത മാനദണ്ഡങ്ങൾ ഓരോ പരീക്ഷയുടെയും തുടക്കത്തിൽ കമൻ്റ് ചെയ്യുക.
2) ദുർബലത നിയന്ത്രണം:
പൊട്ടുന്നതിനായുള്ള ഇനിപ്പറയുന്ന UI ടെസ്റ്റ് പരിശോധിക്കുക:- ഒരു അസ്ഥിരമായ സെലക്ടർ ഉണ്ടോ (നീണ്ട
3) പേജ് ഒബ്ജക്റ്റിലേക്കുള്ള പരിവർത്തനം:
ഇനിപ്പറയുന്ന പ്ലെയിൻ ടെസ്റ്റ് കോഡ് പേജ് ഒബ്ജക്റ്റ് മോഡൽ ഘടനയിലേക്ക് പരിവർത്തനം ചെയ്യുക. സെലക്ടറുകളും പ്രവർത്തനങ്ങളും പേജ് ക്ലാസുകളിലേക്ക് നീക്കുക; ടെസ്റ്റ് ഫയൽ സീനാരിയോ ഫ്ലോ മാത്രം വായിക്കാൻ അനുവദിക്കുക. [ഉപകരണം/ഭാഷ].കോഡ്: [കോഡ് ഒട്ടിക്കുക]
4) കപട പരിവർത്തന തെളിവ്:
ഈ യുഐ ടെസ്റ്റ് യഥാർത്ഥത്തിൽ സാധൂകരിക്കുന്നുവെന്ന് തെളിയിക്കുക: ഈ ടെസ്റ്റ് ചുവപ്പായി മാറുന്ന ആപ്ലിക്കേഷൻ കോഡിൽ ഞാൻ എന്ത് മാറ്റമാണ് വരുത്തുക? പരിശോധനയെ തകർക്കുന്ന ഒരു മാറ്റം നിങ്ങൾക്ക് കണ്ടെത്താൻ കഴിയുന്നില്ലെങ്കിൽ, പരിശോധന അപര്യാപ്തമാണ്; വിട്ടുപോയ ഉറപ്പുകൾ ചേർക്കുക. ടെസ്റ്റ്: [പേസ്റ്റ് ടെസ്റ്റ്]
മൂന്ന് മിനി കേസുകൾ
കേസ് 1 - ദുർബലമായ സെലക്ടറിൽ നിന്നുള്ള മോചനം. AI ഉപയോഗിച്ച് ഒരു ടീം നിർമ്മിച്ച 40 ടെസ്റ്റുകളിൽ 70% ഇൻ്റർഫേസ് അപ്ഡേറ്റിന് ശേഷം തകർന്നു; അവയൊന്നും യഥാർത്ഥ ബഗുകൾ ആയിരുന്നില്ല, അവയെല്ലാം ദുർബലമായ XPath സെലക്ടറുകളായിരുന്നു. "ഫ്രാഗിലിറ്റി ചെക്ക്" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ടീം ടെസ്റ്റുകളെ ഡാറ്റ-ടെസ്റ്റിഡ് ബേസാക്കി മാറ്റി. അടുത്ത മൂന്ന് ഇൻ്റർഫേസ് അപ്ഡേറ്റുകളിൽ, തെറ്റായ ബ്രേക്കുകളുടെ എണ്ണം പൂജ്യമായി കുറഞ്ഞു; അറ്റകുറ്റപ്പണി സമയം ആഴ്ചയിൽ 6 മണിക്കൂറിൽ നിന്ന് 30 മിനിറ്റായി കുറഞ്ഞു.
കേസ് 2 - വ്യാജ പാസിംഗ് യുഐ ടെസ്റ്റ്. AI ഒരു "കാർട്ടിലേക്ക് ചേർക്കുക" ടെസ്റ്റ് നിർമ്മിച്ചു; പരീക്ഷ പച്ചയായിരുന്നു. "വ്യാജ-പ്രൂഫ്-ഓഫ്-പാസേജ്" ടെംപ്ലേറ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, ബട്ടൺ ക്ലിക്കും പേജിൻ്റെ ശീർഷകവും മാത്രം പരിശോധിക്കുന്നതിനായി ടെസ്റ്റ് പ്രത്യക്ഷപ്പെട്ടു, കാർട്ട് കൗണ്ടർ വർദ്ധിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന് ഒരിക്കലും പരിശോധിക്കുന്നില്ല. വണ്ടിയുടെ ലോജിക് പാടെ തകർന്നാലും പരീക്ഷ പാസായി. യഥാർത്ഥ ഉറപ്പ് ചേർത്തു (കാർട്ട് ബാഡ്ജ് "1" ആണ്).
കേസ് 3 - അന്ധമായ കാത്തിരിപ്പ് കെണി. AI നിർമ്മിച്ച സെലിനിയം പരിശോധനയിൽ, ഓരോ ഘട്ടത്തിനും ശേഷം ഉറക്കം (2) ഉണ്ടായിരുന്നു; 60 ടെസ്റ്റുകൾ 14 മിനിറ്റ് എടുത്തു, ഇപ്പോഴും ഇടയ്ക്കിടെ തകർന്നു. ഓപ്പൺ വെയിറ്റിലേക്ക് മാറിയ ശേഷം (ഘടകം ക്ലിക്കുചെയ്യാൻ കാത്തിരിക്കുക) സമയം 5 മിനിറ്റായി കുറയുകയും പൊട്ടൽ അപ്രത്യക്ഷമാവുകയും ചെയ്തു. അന്ധമായ കാത്തിരിപ്പ് മന്ദഗതിയിലുള്ളതും വിശ്വസനീയമല്ലാത്തതുമായിരുന്നു.
സാധാരണ തെറ്റുകൾ
- ദുർബലരായ സെലക്ടർമാരെ അംഗീകരിക്കുന്നു. AI സൃഷ്ടിച്ച ദൈർഘ്യമേറിയ XPaths ഉപയോഗിക്കുന്നത്; ആദ്യ ഇൻ്റർഫേസ് മാറ്റത്തിൽ ടെസ്റ്റുകൾ തകരാറിലാകുന്നു.
- അന്ധമായ `ഉറക്കം` വിടുന്നു. ഒരു നിശ്ചിത കാത്തിരിപ്പോടെ സമയം "പരിഹരിക്കുന്നു"; മന്ദഗതിയിലുള്ളതും നിർണ്ണായകവുമാണ്.
- നിസ്സാരമായ വാദം. പേജ് ലോഡുചെയ്തിട്ടുണ്ടോയെന്ന് പരിശോധിച്ചുറപ്പിക്കുക; യഥാർത്ഥ ഉപയോക്തൃ ഫലം പരിശോധിക്കുന്നില്ല (വ്യാജ-പാസ്).
- POM ഇല്ലാതെ വളരുക. ഓരോ ടെസ്റ്റിനും സെലക്ടർമാരെ വിതരണം ചെയ്യുക; ഇൻ്റർഫേസ് മാറുമ്പോൾ ഡസൻ കണക്കിന് ഫയലുകൾ സ്വമേധയാ അപ്ഡേറ്റ് ചെയ്യുന്നു.
- ഉപകരണം വ്യക്തമാക്കുന്നില്ല. നിങ്ങൾക്ക് ഏത് ഉപകരണം/ഭാഷയാണ് വേണ്ടതെന്ന് AI-യോട് പറയുന്നില്ല; ക്രമരഹിതമായ, പ്രവർത്തിക്കാത്ത കോഡ് ലഭിക്കുന്നു.
- നിങ്ങൾ ജനറേറ്റുചെയ്ത കോഡും പാസും പ്രവർത്തിപ്പിക്കുമ്പോൾ വിശ്വസിക്കുന്നു. കോഡ് തകർത്ത് പരീക്ഷിക്കുന്നില്ല.
ചുരുക്കത്തിൽ
UI ടെസ്റ്റിംഗ് ഓട്ടോമേഷൻ പ്രോഗ്രാം ഉപയോഗിച്ച് യഥാർത്ഥ ബ്രൗസർ ഡ്രൈവ് ചെയ്യുന്നതിലൂടെ ഉപയോക്തൃ പെരുമാറ്റം പരിശോധിക്കുന്നു. AI ഈ കോഡ് വേഗത്തിൽ ജനറേറ്റുചെയ്യുന്നു, പക്ഷേ രണ്ട് വലിയ അപകടങ്ങളുണ്ട്: പൊട്ടുന്ന ടെസ്റ്റുകൾ (മോശം സെലക്ടർ, ബ്ലൈൻഡ് വെയ്റ്റ്), വ്യാജ-പാസിംഗ് ടെസ്റ്റുകൾ (അപൂർണ്ണമായ / നിസ്സാരമായ അവകാശവാദം). സോളിഡ് യുഐ ടെസ്റ്റിംഗിൻ്റെ മൂന്ന് തൂണുകൾ കമ്മിറ്റ് സെലക്ടർ (ഡാറ്റ-ടെസ്റ്റിഡ്), വ്യക്തമായ കാത്തിരിപ്പ്, യഥാർത്ഥ ഉപയോക്തൃ ഫലം സ്ഥിരീകരിക്കുന്നതാണെന്ന് ഉറപ്പ് എന്നിവയാണ്. പേജ് ഒബ്ജക്റ്റ് മോഡലിൽ സൃഷ്ടിച്ച പരിശോധനകൾ അറ്റകുറ്റപ്പണികൾ സമൂലമായി ലളിതമാക്കുന്നു. "എന്ത് മാറ്റം ഇതിനെ തകർക്കും?" എന്ന ചോദ്യത്തോടെ ജനറേറ്റ് ചെയ്ത ഓരോ ടെസ്റ്റും പരിശോധിക്കുക
ആപ്ലിക്കേഷൻ ടാസ്ക്
നിങ്ങളുടെ സ്വന്തം പ്രോജക്റ്റിൽ നിന്ന് ഒരു ഉപയോക്തൃ ഫ്ലോ തിരഞ്ഞെടുക്കുക (ഉദാ. ലോഗിൻ അല്ലെങ്കിൽ തിരയുക). "ശക്തമായ UI ടെസ്റ്റ് ജനറേഷൻ" ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് AI ടെസ്റ്റുകൾ എഴുതുക. തുടർന്ന്: (1) സെലക്ടറുകൾ പരിശോധിച്ച് ശരിയാക്കുകയും "ഫ്രാഗിലിറ്റി ചെക്ക്" ഉപയോഗിച്ച് കാത്തിരിക്കുകയും ചെയ്യുക, (2) ഓരോ ടെസ്റ്റും യഥാർത്ഥത്തിൽ ഒരു "സ്യൂഡോ-പാസ് പ്രൂഫ്" ഉപയോഗിച്ച് സാധൂകരിക്കുന്നുവെന്ന് തെളിയിക്കുക, (3) കോഡ് തകർത്ത് ടെസ്റ്റ് ചുവപ്പായി മാറുന്നത് നിരീക്ഷിക്കുക. ഹാജരാക്കിയതും തിരുത്തിയതുമായ ടെസ്റ്റുകളുടെ എണ്ണവും നിങ്ങൾ കണ്ടെത്തിയ കേടുപാടുകളുടെയും വ്യാജ പാസുകളുടെയും എണ്ണം റിപ്പോർട്ടുചെയ്യുക.
ചെക്ക്ലിസ്റ്റ്
- [ ] ഞാൻ AI-ക്ക് ഉപകരണം, ഭാഷ, സെലക്ടർ നയം, ആർക്കിടെക്ചർ (POM) എന്നിവ വ്യക്തമായി നൽകി.
- [ ] സെലക്ടർമാർ ഡാറ്റ-ടെസ്റ്റിഡ് ആണെന്ന് ഞാൻ പരിശോധിച്ചു.
- [ ] അന്ധമായ ഉറക്കത്തിനുപകരം വ്യക്തമായ/യാന്ത്രികമായ കാത്തിരിപ്പ് ഉപയോഗിക്കുന്നത് ഞാൻ ഉറപ്പാക്കി.
- [ ] ഓരോ അവകാശവാദവും യഥാർത്ഥ ഉപയോക്തൃ ഫലം പരിശോധിക്കുന്നുണ്ടോയെന്ന് ഞാൻ പരിശോധിച്ചു.
- [ ] കോഡ് തകർത്തുകൊണ്ട് ഞാൻ ഓരോ ടെസ്റ്റും പരീക്ഷിച്ചു; അത് ചുവപ്പായി മാറുന്നത് ഞാൻ കണ്ടു.
- [ ] ഞാൻ പേജ് ഒബ്ജക്റ്റ് മോഡൽ ഘടനയിൽ പരിശോധനകൾ ശേഖരിച്ചു.